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.

Educational illustration of tool organization; it is not a screenshot of a real account or the current interface.

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

Hypothetical completed-bar comparison at 10:05 UTC
Input or checkOriginal alertChanged chart
Threshold1.31401.3150
Previous completed close1.31381.3138
Current completed close1.31441.3144
Previous close at or below thresholdYesYes
Current close strictly above thresholdYesNo
Full crossing conditionTrueFalse

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.

1. Which condition is true at the stated completed close?

Previous close 1.3138; current close 1.3144; old threshold 1.3140; new threshold 1.3150.

Show the answer and explanation

C. Apply both inequalities to each version. Passing the preceding-close check alone is insufficient.

  • A. The current close does not exceed the new threshold.
  • B. That reverses which threshold the current close exceeds.
  • C. Correct: the completed close exceeds only the original threshold.
  • D. The previous and current closes satisfy the original crossing rule.
2. How long is emission to webhook receipt in the hypothetical log?

Emission 10:05:00.200; receipt 10:05:00.450; synchronised clocks.

Show the answer and explanation

A. Subtract timestamps for the same two named events. A different starting event produces a different interval.

  • A. Correct: 450−200=250 milliseconds within the same second.
  • B. That measures from the start of the second, not from emission.
  • C. That is the separate emission-to-fill interval.
  • D. The invented log establishes no service guarantee.
3. What does the receiver’s saved webhook record establish on its own?

The receiver has recorded the alert message; no broker response or fill record is supplied.

Show the answer and explanation

D. Keep message delivery, request acceptance and fills as separate facts. Link the records before attributing later activity to an alert.

  • A. A message is not a broker fill confirmation.
  • B. A later chart change does not update the saved running copy.
  • C. The record contains no trade result or cost evaluation.
  • D. Correct: receipt is the recorded event; later execution states need evidence.

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.

LayerWho owns the propertyWhat follows for you
Quote seriesThe 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 indicatorsThe platform — aggregation, timeframe, candle construction; displayed time zoneThe timeframe and chart type can change data and signals. Changing the chart’s displayed time zone changes labels, not Pine calculations or candles.
AlertThe platform's server – the condition is computed on the provider's seriesAn alert says "the condition on this series has been met", not "a trade is possible at this price"
Spread, slippage, rejectionThe broker and the account typeThese 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 executionThe broker's serverStop activation is decided by the broker's quote, not by a line on the chart
Concept illustration: Chart and alert — two different tasks
Educational illustration of tool organization; it is not a screenshot of a real account or the current interface.

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.

Analysis and execution in two windows. If your broker is not integrated with TradingView, the workflow looks like this: analysis in one window, the order in the broker's terminal. This is not a workaround or an inferior variant – it is a consequence of the division of roles described above. Choosing an execution terminal is covered by art. 11.1, while execution models and the cost of an offer belong to the section on brokers.

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:

  1. 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.
  2. 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.
  3. 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.
  4. Instrument specification. Symbol suffix, contract size, trading hours, the way the weekend break is treated.
  5. 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.

A practical rule. Pick one provider for your analysis and stay with it – your levels, drawings and alerts will then remain consistent with one another. Separately, remember that your orders live in a different frame of reference anyway, and check key levels before entry in the terminal where you place the order.

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.

Chart type changes the representation. A plotted value is not a promise of execution.
HA emulator fills can use standard OHLC; a real broker executes on its own Bid/Ask.

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.

An example template for swing work. Main timeframe daily, context timeframe four-hour in a second pane. Indicators: two moving averages in contrasting colours and a volatility indicator in the lower pane. Add markers for the opening hours of the main sessions, saved once and for good. Save the whole thing as a template and load it onto every new instrument. The values are illustrative – the choice of indicators belongs to your system, not to the template; the interpretation of averages and oscillators lives in the technical analysis section.

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.

Bar alerts: when do they trigger?. A historical signal and a realtime event can differ.
This is not a measurement. An intrabar alert need not leave a signal on the closed bar.

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.

A script alert runs on a copy made before your edits. The vendor's documentation describes this unambiguously: at the moment an alert is created for a strategy, a copy of that strategy is made on the server, which runs independently of the version on your chart, and later changes to the settings on the chart do not affect how the copy behaves[2]. For a change of parameters to reach the alert, the old alert must be deleted and a new one created. If you have spent a week adjusting parameters and the alert still behaves "the old way" – that is exactly this mechanism at work, and there is no fault here at all.

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
The alert as a tool for stepping away from the screen. The value of an alert does not lie in speeding up your reaction. It lies in letting you not watch. A trader who does not stare at the chart without reason has fewer opportunities to enter without reason – and excessive trading is associated in research with worse results on retail accounts[5]. This is an argument for alerts as part of organizing your work. It is not an argument for treating them as a source of signals.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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_on without the appropriate offset: it can expose an HTF value on historical bars before that value was available. Requesting a previous, confirmed value, such as close[1] with lookahead_on, is the documented solution for HTF requests, provided the requested timeframe is genuinely higher HTF documentation.
  5. 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.
  6. 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.
  7. 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.
  8. 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.

From an alert to a confirmed order. Each stage can involve delay, failure or rejection.
A webhook reserves no price. Without logs, do not attribute all latency to one layer.

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: calculations, alerts, simulation. A mechanism outline, not a ready account-connected trading robot.
For HTF: close[1] + lookahead_on requests the previous confirmed value on a higher timeframe.

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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 as close[1] and lookahead_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.

If your broker is not on the list – nothing is lost. Analysis in one window, the order in the broker's terminal is a normal working arrangement, following from the division of roles described in section 1. It even has an incidental advantage: it separates the moment of analysis from the moment of clicking, so the reflex "since I am already looking, I may as well enter" meets a small amount of resistance. Choosing the broker itself, execution models and the cost of an offer are the subject of a separate section of the course.

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:

PlanCharts per tabIndicators per chartPrice alertsTechnical alerts
Basic (free)123None
Essential252020
Plus410100100
Premium825400400
Ultimate165010001000

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.

How to decide without looking at the table. Instead of asking "which plan is better", count three things in your own process. How many levels you have to watch at once so as not to miss the situations you actually react to. How many charts you have to see at once to judge context. And – easily forgotten – what type your alerts are. Both pools are counted separately. The same number of levels to watch therefore gives a different answer depending on how you record them. If all three counts fit inside the free plan, paying up buys above all convenience – but you cannot stop at that statement, because the plan also settles features the table above does not cover: webhook notifications[8], the length of an alert's validity period[14] and the number of saved chart layouts[16]. If any of those is part of your process, the sum looks different. And if you regularly delete an alert to make room for a more important one, the limit has already started shaping your analysis – and that is the moment when paying up changes more than convenience.

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.

A watchlist with explicit context. Organization example; an entry is not a trade recommendation.
Provider prefix, units and timestamps help compare the same dataset.

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.

Public Ideas: what remains unseen. Post popularity is not accuracy or an account track record.
Author edits/removal: within 15 minutes. Moderators can hide rule violations later.

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.

What does a Volume bar mean?. First establish the data type and market coverage.
Tick volume can describe source activity, but does not itself measure global spot FX turnover.

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.

Charts and Bid/Ask around a release. Variable-spread illustration; no actual NFP measurements.
To assess a stop, use the broker’s relevant quote side and time, rather than a chart wick alone.

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 checkWhy it changes the outcomeWhere you find the answer
The provider prefix in the symbolA different series means different extremes and a different moment at which a level is touchedThe symbol field on the chart
Which side of the market builds the candleAt 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 candleA different candle means a different signal from the same dayComparing the chart with the broker's terminal
The alert trigger frequencyA condition on an open candle behaves differently from one after the closeThe alert configuration window
Cost settings in the simulationA result without commission and slippage describes a different systemStrategy settings in the results tab
Your broker's spread right nowThe candle does not encode it, and it decides the cost of entryThe 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?
Only if your broker offers an integration and your account type is covered by it. The list of partners changes, so check it in the broker selection panel on the platform and set it against your broker's documentation. If there is no integration, analysis happens in one window and the order in the broker's terminal – that is a normal working arrangement, following from the division of roles between an analytical platform and a trading system.
I changed the script settings and the alert still behaves the old way. Why?
Because a strategy alert works on a server-side copy created at the moment the alert was set up and runs independently of the version on your chart – that is how the vendor's documentation describes it. For a change of parameters to reach the alert, the previous one has to be deleted and a new one created. This is not a defect, only a consequence of alerts being computed on the server rather than in your browser.
The alert rang, but I see no signal at that place on the chart. What happened?
Start by checking whether the condition was not computed on a forming candle – if it was, the values changed before it closed, and after the fact only the final candle remains on the chart, so you are comparing two different measurements. Check in this order: the alert trigger frequency (did it wait for the candle to close), the script's behaviour on historical data versus current data, any change of settings after the alert was created, and the data provider named in the symbol. The full procedure is in section 5 of this article.
Is the volume on a currency pair's chart reliable?
First check what that bar shows for your symbol at all, because it depends on the data source: it can be the number of quote changes at a single provider, it can be turnover measured in one of the currencies of the pair, and for some symbols there is no volume at all and the indicator returns "n/a". In Pine Script the data type is returned by 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?
It is not a substitute for a broker API. The code runs in the TradingView environment and its products are drawings, values and alert events – a strategy can simulate orders in the built-in emulator, but it is a simulation whose result has no status as a record of execution on an account. An alert can send an HTTP request to your application, but it is that application and the broker API that are responsible for placing the order, and every link in that chain can fail. Building the execution layer is the subject of the articles on automation and on Python.
How do I check whether a script behaves differently on history than live?
If the code is accessible, check bar-confirmation timing and HTF requests: not every 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?
Levels can match when the source, quote side and aggregation are consistent, but do not assume that from the pair name alone. Compare the provider, Bid/Ask/mid, session boundaries and observation time. Orders trigger and execute under your broker’s quotes and rules, so verify protective levels in the account’s terminal. Even a small difference matters according to level distance, volatility, spread and execution conditions, rather than solely the number of days a position is held. Take particular care with tight levels and data releases; changing TradingView’s displayed time zone alone does not shift its candles.

Sources and references

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.
  11. 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.
  12. 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.
  13. 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.
  14. 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.
  15. 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.
  16. 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.
  17. 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.
  18. 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.
  19. 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.
  20. 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.
  21. 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.
  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.
  23. 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.
  24. Pine Script® User Manual, "Chart information" – tradingview.com/pine-script-docs/concepts/chart-information. Source of the description of the syminfo.volumetype variable and its four possible values. Checked 2026-08-22.

Your learning progress

Finished this lesson? Mark it yourself. Opening or scrolling a page never marks it complete.

Progress requires JavaScript and browser storage.

Saved only in this browser. No account or cross-device sync. Clearing site data can erase your progress.

Jarosław Wasiński

Editor-in-chief, ForexMechanics.com • Macro & FX analyst

Independent analyst and practitioner with over 20 years of experience in financial markets. Actively involved in Forex since 2007, with a focus on fundamental analysis, OTC market structure, and disciplined capital risk management.

  • Creator and editor-in-chief of MyBank.pl, providing reliable financial education since 2004.
  • Author of hundreds of in-depth market commentaries, structural analyses, and educational materials for traders and investors.
  • Advocate for market transparency, promoting education grounded in hard data and institutional reports (BIS, ESMA, CFTC).

All content is educational and informational only – it does not constitute investment advice or a recommendation. Remember: leveraged trading (Forex/CFD) carries a high risk of rapid capital loss.