TradingView FAQ 2026: 300 Real Questions Answered on Pine Script, Webhooks, Alerts & Backtesting

TradingView has five tiers as of 2026: Free, Essential (around $14.95/mo billed monthly, cheaper annually), Plus (around $24.95/mo), Premium (around $49.95/mo), and Ultimate (around $99.95/mo). Prices fluctuate with regional pricing and seasonal promos, and the live numbers on tradingview.com/pricing are the only ones that should ever be quoted in a trading decision. Annual billing knocks roughly 16-17% off month-to-month, and Black Friday usually goes deeper than that. Worth noting: the old Pro / Pro+ / Premium tier names were renamed to Essential / Plus / Premium in 2024, so a lot of older Reddit threads use names that no longer match the dashboard.

For active traders, yes — Premium is the first tier that stops feeling cramped. You get 25 indicators per chart (vs 2 on Free), 8 charts per layout, 400 server-side alerts, second-based timeframes, Bar Replay deep intraday, and Deep Backtesting. Anyone running automated strategies, multi-timeframe setups, or more than a handful of alerts ends up here. For a casual investor checking SPY once a day, Free is genuinely fine. The "is Premium worth it" thread on r/TradingView resurfaces every few weeks and the consensus is the same: if you find yourself constantly hitting limits on Plus, jumping to Premium pays for itself in workflow time.

Each step up unlocks more indicators per chart, more charts per layout, more server-side alerts, more saved layouts, and better data depth. Roughly: Essential gives 5 indicators / 2 charts / 20 alerts. Plus gives 10 / 4 / 100. Premium gives 25 / 8 / 400 plus second-based intervals, Bar Replay deep intraday, and Deep Backtesting. Ultimate gives 50 indicators per chart, 16 charts per layout, around 1,000 alerts, tick-based intervals, custom intervals, deeper intraday history (40,000 bars), and priority support. The key cliff is between Plus and Premium — that is where the platform stops gating away the features serious users actually need.

Yes — for learning charts, exploring indicators, and forming a methodology, Free is fine. The hard ceilings only really bite once you start trading: 2 indicators per chart, 1 saved layout, 1 server-side alert, 1 simultaneous device, and ads. Most people outgrow Free within a few months. The 2-indicator limit got tightened in late 2023 (it used to be 3) and that change is still the most-upvoted complaint on r/TradingView about the free tier.

Free gets 1 server-side alert. Essential gets around 20, Plus around 100, Premium around 400, and Ultimate around 1,000. These numbers are split between price alerts and technical/script-based alerts on some plans, which is why you sometimes see two different counts quoted. The TradingView pricing page is the source of truth — they tweak the limits roughly once a year. "Server-side" matters because those are the alerts that fire even when your browser is closed; client-side alerts only run while a tab is open.

Free is capped at 2 indicators per chart, Essential at 5, Plus at 10, Premium at 25, and Ultimate at 50. Drawing tools (trend lines, fibs, anchored VWAP drawn from the toolbar) do not count toward the indicator cap. The "Anchored VWAP" indicator does count, but the Anchored VWAP drawing tool does not — that catches people out constantly on r/TradingView.

TradingView offers a 30-day money-back guarantee, but only on your first annual web purchase. Monthly subscriptions, renewals, and add-on data feeds are not refundable. If you bought through the iOS App Store or Google Play, the refund has to go through Apple or Google, not TradingView — that is where most refund threads on r/TradingView go sideways. The actual request is at tradingview.com/support — pick the billing topic and explain the situation.

In your account, go to Account & Billing → Subscription → Manage and turn off auto-renewal. That stops the next charge but keeps your access until the end of the paid period. If you originally paid through the App Store or Play Store, the cancel button on the TradingView site does nothing — you have to cancel from your phone's subscription settings. That mismatch is the single most common reason people end up posting "I cancelled and they still charged me."

Yes — Essential, Plus, and Premium each offer a 30-day free trial. You need a payment method on file, and if you do not cancel before day 30 the card gets charged for the first paid period. Trials are usually one-per-account; if you have already used a trial on Premium you generally can't take another one on Plus.

No. As long as you turn off auto-renewal before the 30-day trial ends, no charge hits your card and you keep paid access until the trial's end date. The cancel button is in Account & Billing → Subscription. Set a calendar reminder — the most common refund complaint is people forgetting and getting auto-billed at midnight on day 31.

Annual is cheaper — roughly 16-17% off the monthly rate. So Essential at around $14.95/mo monthly works out to about $12.95/mo on the annual plan. Black Friday and seasonal promos can push that to 50-70% off the first year, which is the cheapest entry point all year.

TradingView runs a Black Friday sale every year, typically late November through the first week of December. Discounts on Premium have hit 60-70% off the annual price in recent years. They also run smaller flash sales around Valentine's Day, Easter, Labor Day, and occasional $1-first-month offers. If you are not in a hurry, waiting for Black Friday is the standard advice on r/TradingView.

Apple and Google take a 15-30% platform fee on in-app subscriptions, and TradingView passes that through. Subscribing on the website is meaningfully cheaper for the exact same plan. If you already subscribed via the App Store, you usually have to let that sub lapse and re-subscribe on the web to capture the lower price — you cannot just "transfer" the billing relationship.

TradingView does adjust pricing for some lower-income regions (India, Mexico, parts of Southeast Asia), so the same Premium plan can show a lower local price for those users. Using a VPN purely to get a cheaper price violates TradingView's terms of service, and accounts have been suspended for it. If you are travelling for a week, you are fine; if you live in the US and try to subscribe through a Mexico VPN, you are taking a real account-suspension risk.

Free is one device at a time. Essential and Plus are typically 2 simultaneous sessions, Premium gets you more, and Ultimate is the loosest. The exact device counts shifted in mid-2025, so confirm against the current pricing page. If you log in on a third device and you only have a 2-device plan, the oldest session gets kicked out — that is normal, not a bug.

Account & Billing → Plans & Billing → choose the higher tier. TradingView credits the unused portion of your current plan toward the new one, so you only pay the difference. If a sale price is running, the upgrade picks up the sale price too — that is one of the few cases where it is worth doing the upgrade during Black Friday rather than at renewal.

Go to Profile Settings → Account & Billing → scroll to the bottom → Delete account. Cancel any active subscription first or you keep getting billed. Deletion frees up the email address for reuse, but published ideas, scripts, and comments under your old username remain visible (TradingView treats those as platform content). Allow a few days for the change to fully propagate.

Yes, by default. Auto-renewal is on the moment you subscribe, monthly or annual. You can disable it in Account & Billing → Subscription → Manage at any time and still keep your paid access until the period ends. TradingView sends a reminder email a few days before renewal, but it lands in promotions/spam often enough that the safer move is to set your own calendar reminder a week before the date.

Pro classification is set by the exchanges (CME, NYSE, NASDAQ), not TradingView itself. The triggers are: trading on behalf of a business entity, being SEC or CFTC registered, working in a financial-services data role, or acting in any investment-adviser capacity. If you tick any of those, exchange data fees jump roughly 50-100x — CME's retail real-time bundle is around $7/month, the professional rate is around $548/month. If you got reclassified by mistake, contact TradingView support with documentation and they will route it back to the exchange to dispute. Critically, if you are reclassified you are liable retroactively for the difference, so do not lie on the non-pro declaration.

Ultimate adds tick-based intervals, custom intervals, deeper intraday history (40,000 bars vs Premium's 20,000), 50 indicators per chart (vs 25), 16 charts per layout (vs 8), more simultaneous devices, the highest alert count (~1,000), and priority support. It is overkill for almost everyone — most active retail traders run Premium and never feel constrained. Ultimate makes sense if you are running tick charts, scalping with custom intervals, or running a personal trading desk with many parallel layouts.

It depends on your plan. Free is 1 chart per layout, Essential 2, Plus 4, Premium 8, and Ultimate 16. The "Select Layout" grid icon next to the layout name is where you switch between 1-up, 2-up, 4-up, 6-up, etc. Premium's 8-chart layout is what most active multi-timeframe traders end up on; Ultimate's 16-up is overkill unless you are running a desk.

Click the "Select Layout" button at the top of the chart (small grid icon, just to the right of the layout name) and pick the arrangement you want. The chart splits immediately. Each pane behaves like its own chart with its own symbol, timeframe, indicators, and drawings — they only share whatever sync settings you turn on.

Open the Select Layout menu and scroll to the bottom — you will find toggles for Sync Symbol, Sync Interval, Sync Crosshair, Sync Time, and Sync Date Range. Turn on whichever ones you want shared across panes. Most multi-timeframe traders sync symbol and crosshair but leave intervals independent, so the same ticker shows on the 1m, 5m, 1h, and 1D simultaneously.

By default, drawings live on a single chart-and-symbol combination. To get them onto other panes, click the small overlapping-squares icon in the drawing toolbar (or right-click the drawing) and choose "Sync in layout" or "Sync globally." Sync in layout copies the drawing to other panes in this layout that show the same symbol; Sync globally pushes it to every layout you have. This is the source of about half the "my fibs disappeared" panic posts on r/TradingView.

A chart layout is the entire workspace — every chart, drawing, indicator, color, and timeframe saved together. An indicator template is just a saved bundle of indicators with their settings, applied on top of any chart. People mix the two up constantly. Layouts have plan-based save quotas (Free = 1, Essential = 5, Plus = 10, Premium and Ultimate = unlimited); indicator templates are effectively unlimited and global.

Click the layout name dropdown at the top of the chart and pick Save (Ctrl/Cmd+S) or Save As. A blue dot under the layout name means there are unsaved changes. Free plan only stores 1 layout, so saving overwrites it; paid plans let you keep multiple named layouts and switch between them.

Click the "?" icon in the bottom-right of the chart, or visit tradingview.com/support/shortcuts. Mac users swap Alt for Option in every shortcut.

The big ones: Alt+L (log scale), Alt+P (percent scale), Alt+I (invert), Alt+T (trendline), Alt+F (fib), Alt+H (horizontal line), Shift+F (fullscreen chart-only), Ctrl+Z/Y (undo/redo), Ctrl+S (save layout), Ctrl+scroll (zoom in/out). On the desktop app you also get Ctrl+T (new tab), Ctrl+N (new window), and Ctrl+U (duplicate tab). Memorise Alt+L and Alt+T first — those two alone save hours over a year.

Right-click the price axis on the right and pick Logarithmic, or hit Alt+L (Option+L on Mac). The "L" badge at the bottom-right of the price scale also toggles it. Log shows equal percent moves; linear shows equal dollar moves.

Use log for anything multi-year or for assets with big percentage moves — BTC, TSLA, NVDA, biotech penny stocks. A 10% move at $10 looks identical to a 10% move at $100, which is what your eye actually wants. Use linear for short-term and intraday work where dollar moves matter more than percent moves. The "every long-term BTC chart should be log" advice on r/Bitcoin is genuinely correct.

Click the bar-style dropdown at the top of the chart (it looks like two candles next to each other) and pick the type you want. Heikin Ashi, Renko, Kagi, Point & Figure, Line Break, Range, and Volume Candles are all available. Renko, Kagi, and Range need a box-size or ATR setting in their indicator config — TradingView will prompt you the first time you switch.

Bar magnifier is a Premium-and-above feature that runs your strategy backtest using lower-timeframe OHLC inside each chart bar, instead of just open-high-low-close. It produces dramatically more realistic intrabar fills, especially for stop-loss and take-profit logic. Enable it in the strategy properties under "Recalculate / Bar magnifier." Capped at 200,000 lower-TF bars per backtest, so very old chart bars on long histories may not be magnified.

Click the time at the bottom-right of the chart and pick a zone, or open Chart Settings (gear icon) → Symbol/Timezone tab. The candles themselves do not change — only the labels on the x-axis. Most futures traders pick "Exchange" so the chart shows CME / NYSE local time regardless of where they actually live.

In the time-zone dropdown (bottom-right of the chart), the very first option is "Exchange." Pick that and the x-axis switches to the symbol's home exchange time — useful for futures traders trying to anchor session opens to the actual CME open instead of their wall-clock time.

Click your profile picture (top-right) and toggle "Dark color theme." Or right-click the chart background → Color theme → Dark/Light. The preference syncs across web, desktop, and mobile when you are signed in.

Open Chart Settings (gear icon) → Symbol tab. There are separate up-color and down-color inputs for the body, border, and wick, plus checkboxes to disable each layer. Hollow candles (border only, no fill) is a popular tweak — uncheck the body fill on both up and down candles.

Chart Settings → Canvas (or Appearance) tab → set Grid lines dropdown to None. Or just drop the vertical and horizontal opacities to 0. A clean canvas reads much better in screenshots and on Twitter.

Right-click the price scale → Invert scale. Hotkey is Alt+I. The trick is mostly used to visually compare inversely correlated assets — flipping a DXY chart upside down makes the EURUSD relationship obvious.

Right-click the right scale → Percent, or hit Alt+P. The chart anchors to a reference bar (usually the leftmost visible) and shows everything as % change from there. Useful when comparing assets at different price levels.

Click the "+" Compare or Add Symbol button next to the ticker at the top of the chart. You will be asked whether to add it on the Same % scale (good for comparing performance), New scale on right (good for comparing absolute prices), or New pane (good when scales are wildly different). The default Same % scale is what most people want.

Use the TradingView Desktop app — multi-monitor support has been free for all plan tiers since 2024. Open new windows with Ctrl/Cmd+N and drag each to its own display, or detach a tab from the tab bar. Color-tag tabs to link them so changing the symbol in one updates the others. Browser tabs can't do true multi-monitor with shared state, which is the main reason power users move to the desktop app.

Shift+F is TradingView's native fullscreen — it hides the toolbars and gives you just the chart. F11 is browser fullscreen, which is different (it hides the browser chrome but keeps TradingView's toolbars). Shift+F is what you want for clean screenshots.

Click the "ETH" toggle at the bottom-right of the chart, or open Chart Settings → Symbol → Extended Trading Hours. Only works on intraday timeframes (less than 1D). Free plan with the default CBOE BZX feed only shows regular hours; pre/post requires either a primary-exchange data subscription or a feed that includes ETH data by default.

Right-click the volume bars on the chart → Move to → New pane below. Or drag the "Volume" label from the legend down to the bottom of the chart. The pane is resizable; grab the divider and pull.

Drawings are tied to the chart-and-symbol pair by default. Switch to a different ticker on the same chart and they vanish until you switch back — they did not delete, they are just hidden. To make a drawing follow you across symbols, right-click it and choose "Sync globally." Across layouts, you also need autosave on, otherwise unsaved drawings are lost when you close the tab. The "drawings disappeared" thread on r/TradingView resurfaces about once a week and it is almost always one of these two causes.

Click the "Indicators" button at the top of the chart (the one with the fx icon) and search for what you want — RSI, MACD, anything. Click it once and it loads onto the chart. The same dialog has tabs for built-in indicators, your saved scripts, the public library of community scripts, and your favorites.

2 on Free, 5 on Essential, 10 on Plus, 25 on Premium, and 50 on Ultimate. The Free cap was tightened from 3 to 2 in late 2023, which is still the most upvoted complaint on r/TradingView. Drawing tools (trend lines, fibs drawn from the toolbar) do not count toward this limit.

Hover over the indicator's label in the top-left of the chart and click the X. To wipe everything at once, right-click an empty area of the chart and pick "Remove Indicators." It only removes indicators, not drawings or templates.

Click the eye icon next to the indicator name in the top-left legend. It hides the plot but keeps the indicator loaded with all its settings. Click again to bring it back. Useful for decluttering before a screenshot without losing your config.

In the Indicators dialog, click the star next to any indicator. Starred items appear in a quick-access toolbar above the chart so you can add them with one click. Same trick works for drawing tools, financials, and timeframes.

Yes — just add it twice from the Indicators dialog. Each instance keeps its own settings, so you can run a 7-period RSI alongside a 21-period RSI on the same pane. Both count against your per-chart indicator cap, so two RSIs is two of your slots.

Open the indicator's settings (gear icon next to its name), make your changes, then click the "Defaults" dropdown at the bottom of the settings dialog and pick "Save as default." Every new instance of that indicator from now on will load with your settings instead of TradingView's factory ones.

An indicator template bundles a group of indicators (each with their settings) into a single saved object you can apply to any chart. Click the small grid icon next to the Indicators button → Save Indicator Template, name it, optionally remember the symbol and interval, and you are done. Different from a chart layout, which saves the whole workspace.

Indicators with a different value range than price (RSI 0-100, MACD oscillating around 0, Stochastic 0-100) automatically render in their own pane. Indicators that share price's range (moving averages, Bollinger Bands, VWAP) overlay on the price chart. The script's `overlay=true` flag controls this — for built-ins it is set sensibly already.

Right-click the indicator's plot or its label and pick Move To → New Pane Above / New Pane Below / Existing Pane / Above Price. Useful if you want RSI overlaid on the price chart, or if you want all your oscillators stacked into one pane to save space.

Click the gear icon next to the indicator name → Style tab. Each plot has its own color, line thickness (1-4), line style (solid/dashed/dotted), and plot type (line/area/columns/cross). Save these as your default per the earlier question and you stop tweaking colors every time.

Indicator settings → Style tab → uncheck "Labels on price scale" and "Values in status line." Cleans up the top-left clutter and the right-axis number labels. r/TradingView users with 5+ indicators on one chart use this to keep the screenshot readable.

20-period simple moving average with 2 standard deviations. That is the original John Bollinger spec and TradingView ships it that way out of the box. You can change length, standard deviation multiplier, and source in the indicator settings.

EMA weights recent prices more heavily, so it reacts faster but produces more whipsaws. SMA is equal-weighted and smoother, lagging more in fast moves. The standard intraday playbook is 9/21 EMA for entries and a 200 SMA for trend bias. There is no objectively "better" choice — pick the one whose lag character matches your timeframe and stick with it.

Anchored VWAP is a drawing tool (left toolbar, not the Indicators dialog) that draws a volume-weighted average from a bar you pick forward. Click the tool, click the anchor bar (often a swing high, swing low, or earnings date), and the line builds out from there. Drag the anchor dot to re-anchor. Important nuance: the Anchored VWAP drawing tool does NOT count toward your indicator limit, but the Anchored VWAP indicator (added via the Indicators dialog) does.

Defaults are ATR length 10 and factor 3. The factor multiplies ATR to set how far away the bands sit from price — lower factor (1.5-2) means the bands are tight, more flips, faster signals; higher factor (4-5) means wider bands, fewer signals, less whipsaw. r/Daytrading users on 1m and 5m charts often run factor 1.5-2; swing traders on the 1H/1D usually stick with 3.

9, 26, 52 with displacement 26 — Goichi Hosoda's original 1969 settings. Tenkan-sen 9, Kijun-sen 26, Senkou Span B 52, cloud projected forward 26 bars. You will see "crypto Ichimoku" articles recommending 10/30/60 or 20/60/120 — those are not TradingView defaults, they are community modifications. The 9/26/52 numbers are based on a six-day work week from 1960s Japan, but the system still works fine on modern markets.

It is the price field the indicator does its math on. close is the bar's close price, hl2 is (high+low)/2, hlc3 is (high+low+close)/3, ohlc4 is (open+high+low+close)/4, hlcc4 weights close double. Most indicators default to close. Switching to hlc3 or ohlc4 smooths an indicator slightly because it pulls in more of each bar's range.

Open the indicator's settings → Inputs tab → there is a "Timeframe" dropdown. Pick a higher TF (you can't go lower than the chart). The "Wait for timeframe closes" checkbox controls whether the value updates intra-bar or only when the higher TF bar confirms — leave it checked to avoid repaint headaches. Classic example: daily RSI plotted on a 5-minute chart for swing-bias context.

Yes — right-click the indicator's plot line and pick "Add alert on RSI" (or whatever indicator it is). The alert dialog opens with the indicator pre-selected; you choose a condition (Crossing, Greater Than, Less Than, Crossing Up/Down, Entering/Exiting Channel) and a threshold. Works on every built-in. No Pine Script required.

Pine Script is TradingView's proprietary scripting language for writing custom indicators, strategies, screeners, and libraries. It runs sandboxed on TradingView's servers — one execution per bar — and cannot place real trades by itself; live execution requires alerts plus a broker bridge. The current version is v6 (released Q4 2024).

Click the "Pine Editor" tab at the bottom of the chart to open it. Then "Open" → "New blank indicator" or "New blank strategy." Edit the code, hit Save (Ctrl/Cmd+S), then click "Add to chart" to apply it. You can detach the editor into its own window if you want more screen space.

It is the version directive — it tells the compiler which Pine Script version your code targets. Must be the very first non-comment line of the script. Without it, TradingView assumes v1 and most modern code instantly fails to compile. v6 is the current latest; older scripts with //@version=5 still run.

Three lines: //@version=6, indicator("My Script"), plot(close). Save and add to chart and you get a blue line tracing the close price. That is the canonical starting point used in every Pine tutorial.

v6 was the biggest jump since v4-to-v5, and it makes the type system stricter and the language more dynamic. The breaking changes that bite people most often: integer division returns float now (5/2 = 2.5, not 2), implicit int-to-bool casting was removed (if myInt errors — you have to write if myInt != 0), bool variables can no longer be na, the transp parameter was removed everywhere (use color.new(c, transparency) instead), and the when argument on strategy orders was removed. The wins: dynamic request.security arguments, lazy boolean evaluation, larger string limits, footprint data, and the new input.enum type.

No — v5 scripts still run. New scripts default to v6 in the editor. There is a "Convert to v6" helper in the editor's "..." menu that handles the easy stuff automatically; you usually still need to fix a handful of type-cast issues by hand.

v6 made integer division return a float when the result is not whole. If you actually want the floored integer (the v5 behaviour), wrap with int(): int(5/2) returns 2. This bites people upgrading old scripts that index arrays with integer math.

v6 removed implicit numeric-to-bool casting. if myInt errors with "cannot use int as bool." Write if myInt != 0 or if bool(myInt). This single change is the most common compile failure when upgrading v5 scripts.

study() was renamed to indicator() all the way back in Pine v5. Anyone copy-pasting v3/v4 code from old forum posts hits this. Rename to indicator() and add //@version=6 at the top.

The transp parameter was deprecated in v5 and fully removed in v6. Use color.new(myColor, transparency) wherever you used to pass transp. So plot(close, color=color.blue, transp=80) becomes plot(close, color=color.new(color.blue, 80)). Transparency is 0 (opaque) to 100 (invisible).

indicator() scripts plot, render drawings, and fire alerts. strategy() scripts add backtesting and simulated orders via strategy.entry, strategy.exit, etc., and unlock the Strategy Tester tab. You cannot mix the two — a script is either an indicator or a strategy. Calling strategy.entry from inside an indicator is the most common "function does not exist" error.

It tells TradingView to render your script's plots on top of the price chart instead of in a separate pane. Use overlay=true for moving averages, VWAP, support/resistance — anything in price units. Leave it false (the default) for RSI, MACD, oscillators — anything with its own value range.

plotshape(longCondition, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small) draws a green up-triangle below every bar where longCondition is true. location.belowbar, location.abovebar, and location.absolute are the common placements. For text labels instead of shapes, use label.new().

Use a ternary in the color argument: plot(close, color = close > open ? color.green : color.red). Pine accepts series color in plot() so it re-evaluates each bar. Same trick works for bgcolor(), plotshape(), and most plotting functions.

bgcolor(myCondition ? color.new(color.orange, 80) : na). The na on the false branch tells TradingView to skip painting that bar entirely. Always wrap colors in color.new() with high transparency (80-90) when shading large regions, otherwise the chart becomes unreadable.

length = input.int(14, "Length", minval=1) creates an integer input box that shows up in the script's settings dialog. v6 has a full input family: input.int, input.float, input.bool, input.string, input.color, input.source, input.timeframe, input.symbol, input.session, input.time, input.price, input.text_area, and the new input.enum. Use group= and inline= to organise them visually.

tf = input.timeframe("D", "Higher TF") renders TradingView's standard timeframe dropdown. Then use it: htfClose = request.security(syminfo.tickerid, tf, close). Pair with lookahead=barmerge.lookahead_off to avoid future-leak repaint.

= declares a new variable. := reassigns an existing variable. x = x + 1 errors because = wants a new declaration; you need x := x + 1. This is the second most common Pine compile error after the v5/v6 type casting issue.

var x = 0 initialises x only on the first bar of the script and persists the value across all subsequent bars. Without var, x resets to its initial value every bar. Use var for counters, accumulators, and any state you want to carry forward (e.g., counting how many bars since the last entry).

Pine uses indentation like Python — 4 spaces, not tabs. if cond \n     body \n else if cond2 \n     body2 \n else \n     body3. Mixing tabs and spaces is the #1 silent cause of "end of line without line continuation" errors. The Pine Editor inserts spaces by default; if you paste code from another editor, watch for tabs.

na(x) returns true when x is na. nz(x) replaces na with 0; nz(x, y) replaces na with y. Common on early bars where a 200-period SMA hasn't filled yet — guard with if not na(myMa) before using the value. In v6, nz() cannot be used on bool variables because bool can't be na.

close[1] = previous bar's close. close[2] = two bars ago. close[0] is the same as close. You cannot reference the future — close[-1] is invalid. In v6 you also cannot apply [] directly to literals; assign to a variable first.

ta.sma(close, 20). To plot it: plot(ta.sma(close, 20), "20 SMA", color.blue). v5 renamed sma() to ta.sma() (everything moved into the ta. namespace) and v6 kept it that way.

ta.crossover(fast, slow) returns true on the bar where fast crosses above slow, and false on every other bar. ta.crossunder() for the opposite. ta.cross() for either direction. Big gotcha: these only return true on the crossing bar — they do not stay true while fast remains above slow. If you want continuous "fast above slow," just use fast > slow.

Almost always a missing closing parenthesis or bracket on a previous line, or a trailing comma. The Pine Editor highlights the next line, not the broken one, which is why it feels mysterious. Walk back from the highlighted line and count parens. The Stack Overflow pine-script tag is full of these — and the fix is almost always a typo two lines up.

Three common causes: (1) typo or case mismatch — fastMA is not the same as fastMa, Pine is strictly case-sensitive; (2) you used the variable before declaring it; (3) you declared it inside an if block and tried to use it outside (variables declared in a block are scoped to that block). Built-ins are also lowercase only — Close is undeclared, close is the built-in.

Some function arguments require a constant or "simple" value that doesn't change bar-to-bar — examples include the length argument on certain TA functions, timeframe strings on request.security, and max_bars_back. Passing a value computed from close (which is a series) fails because series flows up the qualifier hierarchy: const ⊂ input ⊂ simple ⊂ series. To fix, derive the value from input.int() or use a hardcoded literal.

There is no print() function in Pine. To inspect values visually, use label.new(bar_index, high, str.tostring(myValue)) which puts a text label on the chart, or log.info("RSI is " + str.tostring(rsi)) which writes to the Pine Logs panel (introduced 2023). Logs are the cleaner debugging path and don't clutter the chart.

Built-in vars: year, month, dayofmonth, dayofweek, hour, minute, second — all in the exchange's timezone. dayofweek returns 1 (Sunday) through 7 (Saturday); the constants dayofweek.monday through dayofweek.friday exist for readability. time and timenow return UTC milliseconds since epoch.

No. Pine runs sandboxed on TradingView's servers and has no API to your broker. To trade live you fire a TradingView alert from your Pine code and route it through a webhook bridge — TradingView's own Pine FAQ confirms strategies cannot place orders on a connected brokerage account directly. PickMyTrade is one of the bridges most futures traders on r/algotrading use to convert those alerts into real broker orders. The bridge layer is what closes the gap between "my Pine signal fired" and "my broker filled."

By default, request.security with lookahead_off on a not-yet-closed higher-timeframe bar returns the developing value — not the confirmed close. On the realtime bar that value flickers as new ticks come in. After the chart bar closes (or you refresh), Pine recalculates using the now-confirmed HTF data and the historical bar paints differently than it did in real time. That mismatch is repaint. The fix depends on whether you can tolerate one bar of latency: either request.security(syminfo.tickerid, htf, close[1], lookahead=barmerge.lookahead_on) (the canonical "non-repainting HTF" pattern, which gives you the previous closed HTF bar's value) or just gate your logic with barstate.isconfirmed. The TradingView official docs have a whole "Repainting" section worth reading; r/algotrading users complain about this more than any other Pine issue.

lookahead_off (the default) is safe — the function never returns data that wouldn't have been known on the chart bar. lookahead_on tells Pine "you are allowed to fetch values from a higher-timeframe bar before it closes." On its own, lookahead_on creates future leak — your historical chart will show HTF closes before they happened, which is hindsight bias and ruins backtests. Lookahead_on is only safe when paired with an offset like close[1] on the higher TF, because that offsets you back by one bar so you are still asking for confirmed past data. Use the combination, never lookahead_on alone.

There are two patterns. Pattern A: request.security(syminfo.tickerid, htf, close[1], lookahead=barmerge.lookahead_on). The close[1] shifts the lookup back by one HTF bar so you always get the most recent CONFIRMED HTF close, and lookahead_on ensures historical bars also see that confirmed value at the right moment. The cost is a one-bar delay — you don't see the freshest HTF close until the next HTF bar opens. Pattern B (latest-bar mode): use lookahead_off and gate your logic with barstate.isconfirmed, so you ignore the live developing bar and only act on confirmed bars. Pattern A is more common in production indicators; Pattern B is cleaner when you are inside a strategy and want process_orders_on_close behaviour. Both are non-repainting; pick whichever maps to your latency tolerance.

gaps_off (default) fills the result with the last non-na value when the higher TF has no new bar yet — so an HTF EMA stays "hot" on every chart bar. gaps_on returns na on chart bars where the HTF hasn't produced a new bar — so the value only updates at HTF bar opens. The Pine Scripters Network forum has a long thread where someone's HTF EMA looked stale for ten bars; the cause was gaps_off doing exactly what it is supposed to.

Use request.security_lower_tf(). It returns an array — one element per intrabar bar inside each chart bar. So on a 1H chart asking for 1m data, you get up to 60 elements per chart bar. The total is capped at around 100,000 intrabar bars per chart at most plan tiers. Use array.get() to read individual intrabars or array.avg() / array iteration to aggregate. PineCoders' lower_tf library wraps the most common patterns.

40 request.* calls per bar on most paid plans, up to 64 on Ultimate. There is also a token budget across imported libraries (around 1M tokens aggregated) and a per-script compiled-token cap of around 100K. Hit the request limit and your multi-symbol scanner stops adding tickers. Workaround: use the official Pine Screener, which can scan a full watchlist using one indicator instead of fanning out request.security calls.

Hard-code a list of tickers and call request.security on each, then output results in a table. v6's dynamic_requests=true (the default) lets you pass series ticker arguments, which simplifies the loop pattern, but the 40-call cap still binds — you cannot scan 100 symbols from one script. For more than 40 symbols, the right tool is the Pine Screener (Premium feature). Community scripts like QuantNomad's "Ultimate Custom Screener" max out exactly 40 because of this hard limit.

myArr = array.new<float>() creates an empty array. array.push(myArr, close) appends. array.size(myArr) for length, array.get(myArr, i) to read by index, array.set(myArr, i, x) to write. To loop: for i = 0 to array.size(myArr) - 1. The v6 typed-array syntax (array<float>, array<line>) is preferred over the legacy array.new_float() form.

Arrays and matrices cap at 100,000 elements. Maps cap at 50,000 key-value pairs. Hit those and Pine throws "array size exceeded" at runtime. Most production indicators stay well under these limits; if you are bumping them, your design probably needs to aggregate or roll over older data.

Use matrix when you actually need 2D math — multiplication, inversion, determinants, pseudo-inverse. matrix.mult, matrix.inv, matrix.det, matrix.pinv are all built-in. For loose 2D data where you do not need linear algebra, an array of arrays works fine and is sometimes more flexible because each row can be a different length.

Maps are unordered key-value collections with O(1) lookup by key. Keys can be string, int, float, bool, or a UDT; values can be any type. m = map.new<string, float>(), map.put(m, "AAPL", 192.5), map.get(m, "AAPL"). Prefer maps over arrays when you keep needing to find an element by name or ID — looping an array is O(n), map lookup is O(1). Cap is 50,000 pairs.

A UDT is a custom struct-like type you declare with the type keyword. Example: type Trade \n     float entry \n     float stop \n     int barIdx. Then t = Trade.new(close, low, bar_index) creates an instance. Field access is dot-notation: t.entry. Critically, UDTs are reference types — if you put a UDT into an array and modify the field on the array element, you have modified the "original" object, because the array stores a reference, not a copy. This bites people once. Field history uses parentheses: (myObj[10]).field, not myObj.field[10].

method foo(MyType this, int x) => this.field + x. Methods enable dot-call syntax on instances: myObj.foo(5). Methods can be exported from a library with export method. Useful for keeping related logic close to the type definition and for chaining method calls fluently.

All three are reference types. If you pass an array into a function and the function mutates it, the original array is mutated. Same for UDTs and maps. To get a true copy, use array.copy(), build a new UDT with the fields you want, or rebuild a map from scratch. This trips up developers coming from C-family languages where structs are value types.

Declare the script with library("MyLib") instead of indicator()/strategy(), then mark each shareable function with export: export myFunc(int x) => x * 2. Save and publish (the Publish button in the editor — public libraries are visible to all, private libraries are visible only to you). Then in any other script: import yourUsername/MyLib/1 as ml and call ml.myFunc(5). The "/1" pins to library version 1 — TradingView won't auto-upgrade you to a future breaking version. UDTs used in any exported function signature must also be marked export.

Yes. Prefix the type with export in the library and any UDT used in an exported function signature must itself be exported. Methods export with export method. The consumer script imports the library and can use the UDT type directly via the alias.

100,000 tokens per script (compiled), and an aggregate cap of 1,000,000 tokens across all libraries you import. Hit the per-script cap and the editor refuses to compile; hit the aggregate cap and you have to drop a library. In practice this is mostly an issue for very large helper libraries that import other libraries themselves.

Default ~50 of each. Maximum 500 for lines, labels, and boxes. Polylines are separate and capped at 100. Set in the indicator() / strategy() declaration: indicator("X", max_lines_count=500, max_labels_count=500). The argument must be a constant int — you cannot drive it from an input.

When you exceed your max_lines_count / max_labels_count / max_boxes_count, Pine auto-deletes the oldest drawing FIFO to make room — but if your drawings interact with max_bars_back in awkward ways (e.g., very long history references inside drawings), Pine sometimes can't safely garbage-collect and throws this error. The fix is usually to raise max_*_count toward 500 and/or reduce how many drawings you create. QuantNomad has the canonical write-up on this.

var t = table.new(position.top_right, 2, 5, bgcolor=color.gray) creates a 2-column, 5-row table anchored to the top-right of the chart. Then table.cell(t, 0, 0, "Label", text_color=color.white) for each cell. Tables float — they are not anchored to bars, so they do not move when you scroll. Position constants: position.top_left, top_center, top_right, middle_left, etc. Wrap the table.new in var so it is created once, not on every bar.

A runtime error meaning your script's memory or CPU footprint exceeded TradingView's per-execution budget. The four common triggers: (1) deep [] history references on many series, which inflate the auto-detected lookback buffer; (2) growing arrays/maps that never trim; (3) too many request.security calls; (4) too many drawing objects (lines, labels, boxes). Mitigations, in order of impact: explicitly set max_bars_back=500 on the variables that need it; trim your arrays; cache request.security results in var instead of recomputing; use calc_bars_count to limit how far back the script even runs. r/algotrading users hit this most often when porting C++ or Python algos that assume cheap memory.

Most series have around 5,000 bars of [] referenceability. The core OHLCV built-ins (open, high, low, close, volume, time) go up to 10,000. So close[2000] works on long histories, but a derived myMa[2000] may fail unless you raise max_bars_back.

var persists across bars but resets on intra-bar updates to the value committed at the last bar close. varip persists across bars AND across intra-bar ticks — every tick on the realtime bar can mutate it and that mutation sticks. varip only diverges from var on the realtime bar; on historical bars they behave identically. The trap: varip state in live trading has no equivalent in the backtest, so a strategy that relies on tick-level varip counters will look great in backtest and behave differently live. Use var by default; use varip only when you genuinely need tick-by-tick state.

request.financial(syminfo.tickerid, "TOTAL_REVENUE", "TTM") fetches trailing-twelve-month revenue. Other periods: "FY" (fiscal year), "FQ" (fiscal quarter), "FH" (fiscal half). Field names like "EARNINGS_PER_SHARE_BASIC", "GROSS_PROFIT", "NET_INCOME" — the full list is in the Pine reference. Data is sourced from FactSet so coverage is broad but not universal; small-cap and emerging-market tickers often return na.

v6 made request.* functions accept series arguments — meaning the ticker or timeframe you ask for can change per bar, or be derived from a variable. In v5 these arguments had to be constants known at compile time and the function had to be called from global scope. The practical win: you can build a multi-symbol scanner where the ticker rotates per bar based on inputs, and you can call request.security from inside an if block conditionally. This dramatically cleans up code that used to need ugly workarounds.

A script declared with strategy() can call all the strategy.* order functions (entry, exit, close, cancel) and unlocks the Strategy Tester tab with backtest metrics. A script declared with indicator() can plot and fire alerts but cannot place simulated orders. The two are mutually exclusive — copy a strategy template into an indicator and strategy.entry will throw "function does not exist." This is the most common Pine error in r/algotrading "why doesn't my code work" posts.

The Strategy Tester is silent on suppressed orders, which makes this hard to debug. Check the canonical causes: (1) the entry condition is never actually true on the loaded history — plot it to verify; (2) insufficient simulated capital to size the order; (3) pyramiding is at 0 (default) and you already have an open position in the same direction; (4) a risk-management rule (max-loss-per-day, etc.) is blocking the side; (5) the entry got submitted but never filled because of the verify-price-for-limits setting. Plot the entry condition as plotshape() and verify it lights up where you expect — that finds 80% of these.

strategy.entry respects pyramiding limits and reverses opposite positions automatically. strategy.order ignores both — it just submits another order regardless of pyramiding or current position. Use strategy.order for grid/martingale strategies that need to bypass pyramiding. strategy.close(id) market-closes a named entry by ID. strategy.cancel(id) cancels a pending limit/stop order by ID. strategy.close_all() flattens everything.

By default, market orders fill on the next bar's open — this is intentional, because the bar where the signal triggers might not have closed yet, so the broker emulator waits to fill at a "tradable" price. To fill on the same bar, set process_orders_on_close=true in the strategy declaration. The trade-off: process-on-close uses the bar's close price as the fill price, which is less realistic for intraday because you cannot really transact at the close.

Use it for end-of-day systems and for strategies where you want signal-and-fill on the same bar in backtests. Avoid it for fast intraday systems because it produces unrealistic fills (you cannot reliably trade right at the close in real life). For automated webhook trading paired with "Once per bar close" alert frequency, this combination is what most webhook bridges (PickMyTrade included) actually want — the alert fires on confirmed bar close and the simulated fill matches what the live execution will do.

It tells the strategy to recalculate on every realtime tick instead of only at bar close. Yes, it causes repaint — TradingView's official docs explicitly state that calc_on_every_tick "invalidates backtest results" because historical bars still calculate once at close, so live behaviour and historical equity curves diverge. Use it only when you absolutely need tick-level reaction (rare for retail strategies) and accept that your backtest is no longer a faithful guide.

Recalculates the strategy immediately after a simulated order fills, instead of waiting for the next bar. Useful when your stop-loss or take-profit needs the average fill price (strategy.position_avg_price) to be set within the same bar. Without it, the avg-price-based exit gets placed one bar late.

Two reasons. First, strategy.position_avg_price is na until the entry bar closes, so a SL/TP based on it can't be placed until the next bar by default. Enable calc_on_order_fills=true to fix that. Second, if you pass both a stop and a loss to strategy.exit, Pine uses stop; if you pass both limit and profit, it uses limit. Be explicit about which pair you want.

Three sizing modes: strategy.fixed (qty in contracts/shares), strategy.cash (qty in account currency), strategy.percent_of_equity (% of current equity). The default is strategy.fixed with default_qty_value=1 — one contract per trade. That is why a brand-new strategy backtest on a $100k account barely moves the equity line; you are trading one contract.

Default is 100,000 in the symbol's quote currency. Set it to your real account size if you are using percent-of-equity sizing — otherwise the equity-curve slope is meaningless.

If you trade a EUR-quoted symbol but set currency=currency.USD on the strategy, Pine auto-converts the equity curve into USD using the prevailing FX rate. Mismatched currency settings are a common source of "why is my P&L wrong" complaints — if you are testing on a non-USD instrument, double-check the currency arg.

Three: strategy.commission.percent (default — % of cash volume), strategy.commission.cash_per_contract, and strategy.commission.cash_per_order. The default commission_value is 0%. A backtest with zero commission can show 30-50% better net profit than live, especially on high-frequency strategies — set this to your real broker's rate before you trust any equity curve.

Slippage is in ticks and applies only to market and stop orders (limit and stop-limit fills are not slipped). Reasonable defaults: 1-3 ticks for liquid futures (ES, NQ, MES, MNQ), 1-2 ticks for major forex pairs, 5-10+ ticks for thin instruments and pre-market. The slippage parameter must be a constant integer — you cannot make it dynamic per bar.

Pyramiding is the maximum number of entries the strategy can have open in the same direction. Default is 0, which means one trade per direction at any time. Set pyramiding=3 and you can stack up to 3 long entries before the engine refuses more. Only strategy.entry respects pyramiding; strategy.order ignores it (which is why grid strategies use strategy.order).

Send your entry, then immediately call strategy.exit("Bracket", "EntryID", stop=slPrice, limit=tpPrice). The from_entry argument is the link — it must match the entry's id string exactly, otherwise the exit attaches to nothing. The exit creates an OCO pair: when one side fires, the other cancels automatically.

Deep Backtesting runs your strategy against the full historical depth available for the symbol within a custom date range, rather than only the bars currently loaded on the chart. The standard tester is capped to bars-on-screen (5K-40K depending on plan). Deep Backtesting is Premium and Ultimate only and supports up to 2,000,000 bars and 1,000,000 trades per run. Toggle it on in the Strategy Tester properties, set start/end dates, and hit Generate Report.

The headline numbers: Net Profit, Profit Factor (gross gains / gross losses, >1 means positive expectancy), Max Drawdown (intrabar), Win Rate, Sharpe Ratio, and Average Trade. None of these matter in isolation. A 90% win rate with profit factor 0.8 is a losing strategy; a 30% win rate with profit factor 2.5 is great. Trade count under ~100 is statistically thin and you should not draw conclusions from it. r/algotrading users frequently call out "high win rate with no drawdown" as the classic over-fit signal.

"Max equity drawdown (intrabar)" is measured per bar from the highest equity peak to the lowest equity valley while a position is open. It will always be larger than "Max Closed-Trade Drawdown," which only measures peak-to-trough between closed trades. Always quote the intrabar number when comparing strategies — it is the honest one because it counts unrealised damage, not just realised losses.

Click the Download button at the top of the Strategy Report. CSV exports just the active tab; XLSX exports all five tabs (Overview, Performance Summary, List of Trades, Trades Analysis, Risk Performance Ratios). Export requires Plus or higher — not available on Free.

Top causes, in order: zero default commission and slippage make the backtest look 30-50% better than reality; intrabar fills assume the strategy can transact anywhere within the bar's range, which is generous; look-ahead bias from request.security with lookahead_on leaks future data; non-standard chart types (Heikin Ashi, Renko) backtest at synthetic prices that do not exist; calc_on_every_tick diverges historical from live. The widely cited rule of thumb on r/algotrading is that live results land at 60-70% of the backtest equity curve once you set realistic costs.

No — TradingView itself flags this as a known issue. Heikin Ashi, Renko, Kagi, Range, and Point & Figure use synthetic OHLC values that do not match real tradeable prices, so simulated fills happen at prices that never existed in real life. Strategies that look amazing on Heikin Ashi consistently die in live trading. PineCoders publishes a "Caution!" warning script specifically for this. Run all strategy tests on standard candles only.

Not natively. TradingView has no built-in walk-forward tool, no Monte Carlo, and no parameter optimizer as of 2026. The standard workarounds: third-party Chrome extensions (RoboQuant, OptiPie) that automate input sweeps, or export the trades CSV and run analysis in Python. The lack of native optimization is a top complaint on r/algotrading and a known platform gap.

Use the symbol's actual point value: MES = $5/point, ES = $50/point, MNQ = $2/point, NQ = $20/point. syminfo.pointvalue and syminfo.mintick give you these in Pine. With strategy.cash sizing you have to factor point value into your math, otherwise a $5,000 cash size on ES would buy 100 contracts, which is not what you mean. strategy.percent_of_equity is generally safer for futures because it sizes to risk capacity rather than dollar amount.

strategy.cancel("MyOrderID") cancels a single named pending order. strategy.cancel_all() cancels every pending order. The id string must match the entry's id exactly — it is case-sensitive and a typo silently does nothing.

Pine cannot place real orders on a connected broker — TradingView's own Pine FAQ confirms strategies cannot trade through the native broker panel. The path is: convert your strategy.entry/strategy.exit calls into alert() messages that emit a JSON payload, attach a single TradingView alert to the strategy with a webhook URL, and let a bridge translate the alert into a real broker order. PickMyTrade is one of the bridges that handles this for futures (Tradovate, Rithmic, TradeStation, ProjectX), forex/CFDs (TradeLocker, Match-Trader), stocks/options (IBKR, Tradier), and crypto (Binance, Bybit) — the alert fires on bar close, the bridge routes it, the broker fills it. Make sure to use "Once per bar close" alert frequency and to match your strategy's process_orders_on_close behaviour to avoid backtest-vs-live drift.

Server-side alerts do — they run on TradingView's servers regardless of whether your browser is open or your machine is awake. Most alerts (price, drawing, indicator with alertcondition(), alert() from any script) are server-side and show a small cloud icon in the alert dialog. A handful of custom client-side alerts only run while a TradingView tab is open. The cloud icon is the tell.

Server-side alerts execute on TradingView's infrastructure — they keep working even with your machine off. Client-side alerts only fire while a TradingView browser tab or desktop app is open and connected. The cloud icon in the alert dialog signals server-side. For automated trading you want server-side every time, otherwise you depend on your browser staying alive.

Six options, all of which can stack on a single alert: Notify on App (mobile push), Show Pop-up, Send Email, Webhook URL, Play Sound, and Send Email-to-SMS / plain text. The Webhook URL field is the one that matters for automation — it is what platforms like PickMyTrade use to receive your alert and forward it to your broker.

Install the TradingView mobile app, sign in with the same account, enable push notifications in the app's settings, and tick "Notify on App" when you create the alert. iOS users also need to allow notifications for TradingView in iOS Settings → Notifications. Android users may need to whitelist TradingView from battery optimization, or push deliveries get killed in the background — that is the most-cited fix on r/TradingView for missing mobile pushes.

Once Per Bar fires on the first tick of a bar where the condition becomes true — even if the condition flips false again before the bar closes. Once Per Bar Close waits for the bar to close, then evaluates the condition once on the confirmed close. Once Per Bar gets you to the trade faster but can fire on signals that disappear; Once Per Bar Close gets you the same signal that shows in your backtest. For automated trading, Once Per Bar Close is almost always the right choice.

Only Once means the alert fires once and then stops. It does not delete itself — it stays in your Manage Alerts list as inactive, so you can re-enable or edit it. Common gotcha: people use Only Once thinking they want a one-shot alert, when what they actually want is Once Per Bar (so the same condition can fire repeatedly on different bars).

Allows the alert to fire multiple times within the same bar, throttled to a maximum of one fire per minute. Useful for streaming price-cross alerts on long timeframes where you want every cross announced even if multiple happen inside one bar. Avoid for automated trading — the multiple fires can create duplicate orders downstream.

You are probably set to Once Per Minute or to Once Per Bar with a condition that flips true and false multiple times intra-bar. Switch frequency to Once Per Bar Close. If you are firing from alert() in Pine, also check the freq argument — alert.freq_all fires on every tick, alert.freq_once_per_bar on the first true tick, alert.freq_once_per_bar_close only at confirmed close.

Once Per Bar fires on the first true tick. If the condition flipped back to false before close, the alert already triggered but the chart only paints confirmed-bar history, so it looks like nothing happened. The fix is to use Once Per Bar Close instead — your alert will only fire on bars where the condition is still true at close, which matches what you see on the chart.

Use Once Per Bar Close on the alert frequency. Avoid request.security with default lookahead (use the [1] + lookahead_on pattern or Once Per Bar Close gating). Avoid calc_on_every_tick=true. In strategies, set process_orders_on_close=true so the simulated fill matches the bar where the alert actually fires. Doing all four eliminates the most common backtest-vs-live drift.

Free is 1 server-side alert. Essential is around 20, Plus around 100, Premium around 400, Ultimate around 1,000. Some tiers split the count between price alerts and technical/script-based alerts, so the total may be higher than the headline number. The pricing page is the source of truth — TradingView quietly bumps these numbers about once a year.

On Essential and Plus, alerts have a hard ~2-month expiration baked in. They go silent without warning when the timer hits zero, which is the silent-killer of automated setups. Premium and Ultimate offer "Open-ended" alerts that never expire — but only if you tick the Open-ended toggle when you create them. Existing alerts created on lower plans keep their old timer until you edit and re-save.

Open-ended is opt-in. When you create an alert, the Expiration field still defaults to a date — you have to switch it to "Open-ended" explicitly. If you upgraded from Plus to Premium, your old alerts kept their old expiration date. Open the alert, change the expiration to Open-ended, save.

TradingView has anti-spam throttling. If an alert fires too many times in a short window (typically dozens of fires per minute, indicating runaway logic), it gets auto-disabled to protect the platform. Fix the underlying condition — usually it is a Pine condition that is true on every tick — and switch to Once Per Bar or Once Per Bar Close, then re-enable.

Price-crossing alerts watch the symbol's price hitting a level (cross above $100, drop below $50, etc.). Indicator alerts watch a plot value from an added indicator — RSI crossing 70, MACD crossing zero, EMA crossing price. The dialog shows different condition options depending on which type you pick from the Condition dropdown.

Crossing, Crossing Up, Crossing Down, Greater Than, Less Than, Entering Channel, Exiting Channel, Inside Channel, Outside Channel, Moving Up, Moving Down, Moving Up %, Moving Down %. Channel options need a high and a low value; Moving Up/Down % needs a percentage threshold over a time window.

Add the RSI indicator from the Indicators dialog. Right-click the RSI plot in its pane → Add alert on RSI. The dialog opens with RSI pre-selected; pick a condition (Crossing 70, Less Than 30, etc.) and you are done. Works on every built-in.

Right-click the drawing → Add alert. Or hover the drawing and click the clock icon in the floating toolbar. The alert references the drawing's coordinates and updates automatically if you move the drawing — re-anchor a trendline and the alert level moves with it.

Not in the alert dialog directly — the condition dropdown is single-condition. To combine, write a Pine indicator with the boolean expression and use alertcondition(myCombinedBool) or alert("..."), then create an alert on that indicator. This is one of the main reasons people start writing their first Pine script.

alertcondition() is indicators-only and takes a constant string message — it registers a static alert template that the user wires up via the alert dialog. alert() works in indicators AND strategies, takes a series string (you can build the message dynamically with current bar values), and fires programmatically when the script's execution hits that line. alert() is the modern, more flexible API; alertcondition() is older but still supported. Almost all webhook automation built today uses alert() with JSON payloads.

When your script uses one or more alert() calls, this option in the Condition dropdown creates a single alert that fires whenever any of those alert() lines execute. The frequency and message come from your Pine code (the freq argument and the message string), not from the dialog's frequency dropdown.

Two paths. With alertcondition(), embed placeholders in the message: {{ticker}}, {{close}}, {{plot_0}} through {{plot_19}}, {{plot("Name")}}. With alert(), build the message dynamically: alert("RSI is " + str.tostring(rsiValue) + " on " + syminfo.ticker). The dynamic version is more flexible and is what most webhook-bound alerts use.

Standard placeholders: {{ticker}}, {{exchange}}, {{open}}, {{high}}, {{low}}, {{close}}, {{volume}}, {{time}} (UTC bar open), {{timenow}} (UTC alert fire time), {{interval}}, {{syminfo.currency}}, {{syminfo.basecurrency}}, {{plot_0}} through {{plot_19}}, and {{plot("Name")}} for plots referenced by title. Strategy scripts add a whole strategy.* placeholder family for order data.

Strategy alerts get extra placeholders: {{strategy.position_size}}, {{strategy.order.action}} ("buy" or "sell"), {{strategy.order.contracts}}, {{strategy.order.price}}, {{strategy.order.id}}, {{strategy.order.comment}}, {{strategy.order.alert_message}}, {{strategy.market_position}} ("long"/"short"/"flat"), {{strategy.market_position_size}}, {{strategy.prev_market_position}}, {{strategy.prev_market_position_size}}. These are exactly what bridges like PickMyTrade consume to translate the alert into a broker order — see PickMyTrade's plot-placeholder docs for example JSON payloads.

Yes — the Stock Screener has an "Alert on stock entering / leaving the screen" option. Each first-match generates a notification. Useful for momentum scans where you want to be told the moment a new ticker meets your criteria. Other screener types (Crypto, Forex, DEX) have similar options; not all conditions are supported on every screener.

A webhook is an HTTP POST that TradingView fires from its servers to a URL you supply, carrying the alert message as the request body. It is "outbound only" — TradingView pushes the data to you when an alert triggers, instead of you polling for it. That URL belongs to whatever receiver you set up: a broker bridge, your own server, n8n, Zapier, Discord, anywhere. Webhooks are the bridge between "TradingView noticed something" and "code somewhere does something about it."

Webhooks require Essential or higher (around $14.95/mo). Free does not include webhook URLs in the alert dialog. Most automated traders end up on Premium because Essential and Plus alerts also have a 2-month silent expiration, while Premium and Ultimate offer non-expiring alerts. The cheapest reliable production setup is Premium annual.

TradingView sends whatever you put in the alert's Message field as the HTTP request body. If the message parses as valid JSON, the request goes out with Content-Type: application/json; otherwise it is sent as text/plain. So a typical PickMyTrade-compatible message field looks like {"action":"buy","symbol":"{{ticker}}","quantity":1,"price":{{close}}}. You design the schema yourself; the receiving bridge tells you what format to use.

In the alert's Message field, write JSON with TradingView placeholders inline. Numeric placeholders like {{close}} and {{strategy.order.contracts}} go unquoted. String placeholders like {{ticker}} need double quotes around them. A working PickMyTrade payload: {"action":"{{strategy.order.action}}","symbol":"{{ticker}}","quantity":{{strategy.order.contracts}},"price":{{close}}}. PickMyTrade documents the full set of supported fields in its plot-placeholder docs at docs.pickmytrade.io.

Four IPs as of 2026: 52.89.214.238, 34.212.75.30, 54.218.53.128, and 52.32.178.7. All in AWS us-west-2 (Oregon). IPv6 is not supported. If you self-host a webhook receiver behind a firewall, allow inbound from these four IPs. Hosted bridges (PickMyTrade, TradersPost, etc.) handle ingress on your behalf so you do not have to manage firewall rules. Re-verify the IP list before publishing — TradingView has changed it once before.

Both HTTP (port 80) and HTTPS (port 443) are accepted, but HTTPS is strongly preferred — your alert message can contain account-routing information, secrets, and trade signals, and you do not want any of that traversing the internet in plain text. PickMyTrade endpoints are HTTPS only.

TradingView explicitly rejects any port other than 80 or 443. No 8080, no 9000, no custom anything. If you self-host, you have to put your receiver behind a reverse proxy listening on 443. There is no appeal — it is a platform-level firewall rule.

Only on HTTP 5xx responses (excluding 504). Five-second delay between attempts, max 3 retries. Any 4xx response, network timeout, or 504 is silently dropped — no retry. This is the single most important fact about webhook reliability and the reason quality bridges absorb the webhook the moment TradingView posts and handle their own retries downstream. PickMyTrade queues every received alert and retries broker delivery independently, so a transient broker outage does not equal a missed trade.

The usual suspects: (1) the alert hit its 2-month expiration on Essential/Plus and silently went inactive; (2) your receiver took longer than 3 seconds to respond and TradingView gave up; (3) your TradingView plan got downgraded and webhooks are no longer included; (4) the underlying indicator was edited/republished, which invalidates attached alerts; (5) you hit your active-alert cap and the latest alert silently fell off the back. Check the Alert Log first — TradingView shows a "Webhook status" column with the HTTP response. PickMyTrade's dashboard logs every received alert independently, so you can confirm whether TradingView actually sent the webhook or never got that far.

TradingView cancels any webhook request that does not return a response within 3 seconds. AWS Lambda cold starts, free-tier Heroku dynos, and slow custom servers commonly fail this. The webhook is dropped silently and there is no retry (because timeout is not a 5xx). Production receivers need to respond fast — ideally under 300ms. PickMyTrade endpoints are designed to acknowledge the alert in well under that limit before any broker work happens downstream.

Wide range. TradingView's alert servers are in AWS us-west-2 (Oregon), so a co-located bridge can ingest the webhook in well under 100ms. Real-world end-to-end (alert fires → broker fills) is typically 1-3 seconds in calm market conditions, but can spike to 25-45 seconds during news or market open. The variance is mostly in the bridge layer — TradingView's leg is fixed, the broker's leg is fixed, but the middle hop is what differentiates fast bridges from slow ones. PickMyTrade's latency-reduction guide at docs.pickmytrade.io covers the optimisation knobs in detail.

Three options. Cheapest: webhook.site gives you a public URL that captures and displays whatever TradingView POSTs — useful to inspect the exact payload. Better: Postman or cURL to mimic TradingView's POST against your receiver and validate the response. Best: a paper-trading or sandbox broker account behind a proper bridge. PickMyTrade has a built-in test mode and demo broker connections so you can fire end-to-end test trades without risking real capital.

Work backwards: (1) open Manage Alerts → Alert Log and check the Webhook status column — TradingView shows the HTTP response code per fire; (2) confirm the URL has no trailing whitespace (a stray space is the most common silent failure); (3) confirm HTTPS not HTTP, and port 443 if specified; (4) confirm 2FA is enabled on your TradingView account (a recent requirement); (5) check your firewall is allowing the four TradingView source IPs; (6) validate your JSON is well-formed. PickMyTrade surfaces both halves of the failure (received from TradingView vs sent to broker) on its dashboard so you can see exactly which hop broke.

TradingView does not support HMAC payload signing. The standard pattern is a shared secret token in the URL path (e.g. /webhook/abc123randomstring) that your receiver validates, plus IP allowlisting at the firewall layer to only accept connections from TradingView's four source IPs. PickMyTrade auto-generates and rotates a per-user webhook URL with the secret embedded, so you cannot accidentally leak a guessable URL.

No. There is no X-Signature header, no HMAC, and no JWT. TradingView relies on SSL certificate verification (only over HTTPS) and the user-defined secret-in-URL pattern. Stripe and GitHub webhook devs migrating to TradingView find this surprising; the workaround is a strong random secret and IP allowlisting.

TradingView mandates two-factor authentication on the account before any webhook URL field will save and fire. The reasoning is account-takeover risk — a compromised account that can fire webhooks could route trades to an attacker's broker. Enable 2FA in account settings before you try to add a webhook URL.

TradingView allows exactly one webhook URL per alert. Three workarounds: (1) middleware like n8n or Zapier that fans out one inbound webhook to many destinations; (2) a custom proxy server that receives and re-broadcasts; (3) a bridge with native multi-destination routing. PickMyTrade can route a single TradingView alert to multiple broker accounts simultaneously — common setup is one alert firing into a live account and a paper/demo account at the same time, or fanning across multiple prop firm accounts.

The major bridges as of 2026: PickMyTrade (futures + multi-broker, $50/month flat, supports Tradovate, Rithmic, IBKR, TradeStation, ProjectX, TradeLocker, Match-Trader, Tradier, Binance, Bybit, plus 27+ prop firms); TradersPost (multi-asset including stocks/options, tiered pricing up to ~$299/month); PineConnector (MT4/MT5 only); AutoView (crypto-heavy after the Chrome extension EOL in early 2025); Capitalise.ai (forex/CFD broker partners); 3Commas and Alertatron (crypto-focused). Plus DIY paths via n8n, Zapier, or a custom server.

Decision tree. Forex/CFD on MT4 or MT5 → PineConnector is the right tool, it is purpose-built for that ecosystem. Stocks/options on US brokers (tastytrade, Tradier) → TradersPost is strong here. Futures (Tradovate, Rithmic, ProjectX) and prop firm challenges → PickMyTrade is the specialist; flat $50/month covers all supported brokers including 27+ prop firms (Apex, Topstep, MFFU, Tradeify), where TradersPost's tiered pricing gets expensive fast. Many active retail traders end up running both PickMyTrade for futures/prop and a different bridge for niche assets.

Yes for non-HFT timeframes (5-minute and slower). The risk factors are real and worth respecting: alerts can expire on lower plans, the 3-second timeout means a slow receiver drops the trade with no retry, the single-region (Oregon) source IPs add a tiny but consistent latency floor, and TradingView itself has occasional outages. Mitigations: stay on Premium for non-expiring alerts, use a hosted bridge that absorbs the webhook fast and queues retries to the broker side, monitor your alert log daily, and run a paper account in parallel with live for a couple of weeks before scaling capital. PickMyTrade and similar production bridges are explicitly designed around these failure modes — built-in idempotency, broker-side retry, dead-letter queues, and execution logging make webhook automation production-grade rather than hobby-grade.

Bar Replay rewinds the chart to a chosen point in history and plays bars forward one at a time, like a paper-trading time machine. Click the Replay icon at the top of the chart (it looks like a fast-rewind ⏪), then click the bar you want to start from, then press play. You can step bar-by-bar with Shift+→ or autoplay with Space (Shift+↓ also pauses).

Daily, weekly, and monthly Replay goes back as far as the symbol has data on every plan — usually decades. Intraday Replay depth is gated by the same per-plan intraday cap as your chart: Free 5,000 bars, Essential/Plus 10,000, Premium 20,000, Ultimate 40,000. Premium and Ultimate also unlock "deep intraday in Bar Replay," which extends 1-minute Replay much further back on supported symbols.

Lower-timeframe data isn't stored that far back on lower plans. The workaround: open Replay on a daily chart first, click a starting bar inside your plan's intraday cap, then drop down to the 1-minute timeframe. Replay re-anchors at the new TF using whatever 1-minute history is available. r/TradingView users hit this constantly when trying to replay setups from years ago on the free plan.

Space toggles play/pause. Shift+↓ also toggles play/pause. Shift+→ steps forward one bar. There is no built-in "step back one bar" — you have to restart Replay at an earlier anchor.

Yes — Bar Replay has built-in Buy and Sell buttons that let you place hypothetical entries and exits as bars play forward. The trades are sandboxed to that replay session only; they do not feed into your paper trading account or affect any real broker. Useful for discretionary skill-building when you want to feel "in the moment" without risking real capital.

Bar Replay is for manual, discretionary forward simulation — you watch each bar form and make decisions in real time. Strategy Tester is for automated, coded backtests with metrics (net profit, drawdown, win rate). They solve different problems. Discretionary chartists live in Replay; systematic traders live in the Strategy Tester. Most active traders use both for different purposes.

Only the bars currently loaded on the chart, capped by your plan's intraday limit (5K-40K bars). On a 1-hour chart that is roughly 2-3 years of history on the free plan, more on higher tiers. To run the strategy on full available history, you need Deep Backtesting.

Deep Backtesting requests the full historical depth available for the symbol, with a custom date range you set, instead of being limited to the bars on your chart. It is Premium-and-above only and is hard-capped at 2,000,000 bars and 1,000,000 trades per run. If your range exceeds 2M bars, only the most recent 2M within the range are computed. Toggle it on in the Strategy Tester properties, set start/end, and hit Generate Report.

Continuous symbols (like ES1!) splice multiple expiration months into a synthetic series for charting. Without back-adjustment turned on, raw stitched price has gaps at every roll, which inflates ATR-based stops and skews moving averages. Deep Backtesting on continuous futures also has stricter caps: N-second timeframes get N×3 months of history, and N-minute timeframes get N×3 years. So a 1-minute Deep Backtest on ES1! goes back roughly 3 years from today. For longer histories, test on specific monthly contracts and accept their shorter individual lifecycles.

The five usual culprits, in roughly the order they damage your equity curve: zero default commission and slippage make the backtest 30-50% too rosy; OHLC-only intrabar simulation lets the strategy fill at any price within the bar's range, which is generous; look-ahead bias from request.security with lookahead_on leaks future data into history; non-standard chart types (Heikin Ashi, Renko) backtest at synthetic prices that do not exist; calc_on_every_tick diverges historical from live. The widely cited rule of thumb on r/algotrading is that live results land at roughly 60-70% of the backtest's net profit once you set realistic costs and run on standard candles. If you cannot stomach a 30-40% degradation, the strategy is not ready.

The broker emulator assumes a price path inside each bar based on which extreme the open is closer to. If the bar opened nearer the high, it assumes O→H→L→C; if nearer the low, O→L→H→C. It treats every value in that range as touchable, so a stop-loss inside the bar always fills at exactly the stop price (no slippage unless you set it). There are no real ticks, just OHLC. This is generous to your backtest, especially for stop-and-reverse strategies that depend on the exact intrabar sequence. Bar Magnifier on Premium replaces this heuristic with actual lower-timeframe data inside each bar, which is meaningfully more realistic.

Bar Magnifier is a Premium-and-above strategy-tester feature that uses real lower-timeframe OHLC inside each chart bar instead of TradingView's open-high-low-close path heuristic. It dramatically improves the realism of intrabar fills, especially for stop-loss and take-profit logic. Capped at 200,000 lower-TF bars per backtest, so very old chart bars on long histories may not be magnified. Enable it in the strategy properties under "Recalculate / Bar magnifier." Always-on for serious strategy testing.

Yes, badly. TradingView's official docs explicitly state that calc_on_every_tick=true "invalidates backtesting results" because historical bars run on close while realtime bars run on every tick — so the backtest equity curve and live behaviour diverge by design. Same trap with request.security using lookahead_on without an offset: historical bars see HTF closes before they would have been knowable, which is hindsight bias. Both make the backtest look better than reality. Audit any "great" backtest for these two flags before trusting it.

Two paths. In the Strategy Tester → Properties dialog, set Commission (% of cash, $/order, or $/contract) and Slippage (in ticks). Or set them in the strategy() declaration: strategy("X", commission_type=strategy.commission.cash_per_contract, commission_value=1.5, slippage=2). Slippage applies only to market and stop orders — limit and stop-limit fills ignore it. The "verify price for limit orders" setting controls how aggressively limits fill (default 0 ticks means a touch fills; raise it for honesty).

No. TradingView itself flags this — backtests on Heikin Ashi, Renko, Kagi, Range, and Point & Figure produce inflated, unrealistic results because synthetic OHLC values don't reflect tradeable prices. PineCoders publishes a "Caution!" warning script specifically for this. The strategies look beautiful and die instantly in live trading. Run all serious strategy testing on standard candles only.

Not natively — there is no walk-forward tool. The manual workaround: split history into in-sample and out-of-sample windows (say, optimize on 2018-2022 data, then run frozen settings against 2023-2025), use the input "..." menu to optimize parameters in-sample, then re-test on out-of-sample without changing anything. For true rolling walk-forward, export the trade list to CSV (Plus or higher) and run the analysis in Python or Excel. The lack of native walk-forward is one of the top complaints on r/algotrading and a known platform gap.

No native Monte Carlo. Workarounds: export the List of Trades to CSV (Premium feature), then run shuffle-based Monte Carlo in Python or Excel to estimate the distribution of possible equity curves. Some community indicators ingest pasted equity curves and run a basic randomisation visualisation, but they are nowhere near as rigorous as a proper Python notebook.

Free for all plans, default $100,000 simulated balance, no broker connection required. It uses TradingView's internal simulator with one universal account per user. Reset it via Trading Panel → Paper Trading → gear icon → Reset Paper Trading Account; the reset is permanent. You can change the starting balance and currency on reset (no longer locked to USD). Useful for testing logic but not the same as a real broker demo — fills and latency in TradingView's simulator are cleaner than live broker behaviour.

TradingView's built-in paper trading uses TradingView's own simulator. To forward-test against a real broker's matching engine and fill behaviour, point your TradingView alerts at a broker demo account through a webhook bridge — Tradovate Sim, Rithmic Test, OANDA demo, etc. PickMyTrade supports demo connections for most of its brokers, so the same alert plumbing you will use in live trading routes into a sandbox account. That validates the full path (alert latency, JSON parsing, broker rejection handling) which the in-platform paper account cannot.

Only at the underlying level. TradingView charts the underlying symbol, not per-strike option chains, and Pine has no IV surface, no expiry-aware P&L modelling, and no multi-leg strategy primitives. You can backtest signals on the underlying that drive option entries, but the actual option leg pricing, theta decay, and expiry handling have to be modelled outside (Option Alpha, ORATS, or QuantConnect for serious option backtesting). For option execution itself, TradingView alerts can fire to a bridge that places the actual option leg at your broker.

Open the screener panel at the bottom of the chart (or full-screen at tradingview.com/screener). Pick the market type at the top — Stock, ETF, Bond, Crypto Coins, CEX, DEX, Forex, or Pine. Then click the "+" button (or hit Shift+F) to add filters: price, volume, market cap, technical conditions, fundamentals. Results update live. Click any row to chart that ticker.

Click Save (Ctrl/Cmd+S) or use the "Save As" dropdown next to the template name in the screener. Templates store filters, sorting, and column choices. Press "." to browse your saved templates and switch between them quickly.

Save the setup first, then click the menu and toggle "Share screen." TradingView generates a link recipients can open and copy into their own account. You cannot share an unsaved configuration — save first.

Pine Screener is a Premium-only tool that runs a Pine Script indicator across an entire watchlist and shows results in a table. Different from a regular screener — Pine Screener can use your own custom indicator logic. Requirements: the indicator must output at least one plot() or alertcondition(), calculations only run on the last 500 bars, and the script can have at most 5 request.* calls.

Three usual culprits. Your script has more than 5 request.* calls — Pine Screener caps it at 5 vs the 40 limit on a regular indicator. Your script has no plot() or alertcondition() output — Pine Screener needs something to show in the result column. Your script depends on more than 500 bars of history — Pine Screener only runs the last 500. Trim accordingly and it will load.

1,000 symbols per watchlist. That is the platform-wide cap regardless of plan. Past that you need a second watchlist.

Free is limited to a single watchlist. Essential and above unlock multiple watchlists — TradingView does not publish exact counts for higher tiers, but in practice anyone past Free has plenty of room. The first paid tier is the meaningful upgrade for watchlist organisation.

Click the watchlist name dropdown → "Upload list…" and pick a .txt or .csv file. Symbols need exchange prefixes — NASDAQ:AAPL,NASDAQ:MSFT,NYSE:JPM, comma-separated. Section dividers are lines starting with ### (e.g. ###Tech). Without the exchange prefix the import either fails or maps to whatever default exchange TradingView guesses, which is rarely what you want.

Open the watchlist in Advanced View, then click Export. CSV gives you symbol + exchange + notes columns; basic TXT gives you just symbols. Useful for backups, transferring to another account, or seeding a Python script.

Right-click anywhere in the watchlist → Add Section. Type the section name and the row becomes a divider. Sections collapse and expand. For text imports, prefix the section line with ### (e.g. ###Crypto) and TradingView treats it as a divider on import.

7 flag colors. Click the flag icon next to a symbol and pick a color. Flagged symbols group under that color in their own filterable list, separate from your regular watchlists. Power users on r/TradingView use them for tagging — green for "watching for entry," red for "in trade," yellow for "earnings this week," etc.

Most common causes: you are signed in to different accounts on each device; autosave is off so changes never persist; or you are looking at a flagged-list view on one device and a "real" watchlist on another. Sign in with the same account everywhere, refresh the watchlist panel, and confirm autosave is on. If you recently edited the watchlist on two devices simultaneously, the older session's edit can overwrite — close the older session before working on the other one.

In the screener's top toolbar there is a Watchlist filter — pick a specific watchlist (or "Flagged") and the screener restricts results to those symbols. Combines well with technical filters: scan only your 50-name watchlist for "RSI < 30 AND price above 200 EMA" instead of the entire universe.

Click "Add alert on the list…" in the watchlist menu. The alert applies to every symbol in the watchlist and auto-applies to symbols you add later. Plan limits on watchlist alerts: Premium 2 active, Expert 10, Ultimate 15. Useful for "wake me when any of these breaks $X" type setups.

TradingView has dedicated Market Movers pages (Pre-Market Gainers, Pre-Market Losers, Pre-Market Gappers, Pre-Market Most Active) at tradingview.com/markets. The regular Stock Screener also has extended-hours columns and filters you can add. Real-time premarket data requires a primary-exchange data subscription — the free CBOE BZX feed is regular hours only.

Use the regular Trend Line tool (left toolbar, hotkey Alt+T) — it draws a finite segment between the two points you click. The Ray and Extended Line tools are different — they extend to infinity in one or both directions. Beginners often grab the wrong one. Trend Line for marked-up swing levels; Ray when you want the line to project forward but anchor at one end.

Draw from the start of the move to the end of the move. In an uptrend that is swing-low to swing-high (so 1.0 sits at the low and 0 at the high). In a downtrend it is swing-high to swing-low. Direction does not change the math — the levels themselves are identical either way — but it determines which end is "0" and which is "1," which matters when you talk about retracement levels with other traders. r/Forex has a thread roughly every week from someone whose fibs look "flipped" relative to a YouTube tutorial; this is always the cause.

Retracement = pullback levels inside an existing move (entry zones — 0.382, 0.5, 0.618, 0.786). Extension = projection beyond the original move (profit targets — 1.272, 1.618, 2.618). Trend-based Fib extension uses three anchor points (start, end, retracement low) to project where the next leg will hit if the prior leg's proportions repeat. Retracements for entries; extensions for targets.

Click the magnet icon in the left toolbar — it turns blue when on. Two modes: weak (snaps when you are near OHLC) and strong (always snaps). Hold Ctrl (Win) / Cmd (Mac) while drawing to toggle magnet on temporarily. Recently extended to also snap to indicator values, so you can land a trendline exactly on a moving average without squinting.

Two scopes. To sync drawings across panes in the same multi-chart layout (same symbol required), click the small overlapping-squares icon in the left drawing toolbar — it turns blue. To make a single drawing follow you across all layouts and timeframes, right-click that drawing → "Sync globally." There is also a "Sync in layout" middle option that syncs within the current layout's panes only. Most heavy multi-chart users leave the layout-sync icon on permanently.

Three likely causes, all common on r/TradingView. First: editing the same layout on two tabs/devices simultaneously — autosave on one overwrites the other. Second: drawings on indicator sub-panes (an RSI pane, a MACD pane) get wiped whenever the indicator is hidden or the indicator template is changed. Third: drawings save per-symbol-per-layout, so switching from BTC to ETH on the same chart "loses" your BTC drawings — they will return when you switch back. None of these is a bug; they are just the model TradingView uses.

Per-symbol within a layout. Switch the symbol on a chart and your prior drawings hide; switch back and they return. The "Sync globally" right-click option promotes a single drawing to layout-spanning so it travels with you no matter which symbol or layout you open.

Right-click the drawing → Add alert. Or hover the drawing and click the clock icon in the floating toolbar. Works on Trend Line, Horizontal Line, Ray, Channel, Rectangle, and Anchored VWAP. The alert tracks the drawing's coordinates, so if you re-anchor the trendline, the alert level updates automatically. Free plan technically supports 1 active alert, but realistically you want Essential ($14.95/mo) or higher for any meaningful drawing-alert workflow.

Right-click the drawing → Lock. Or click the padlock icon in its floating toolbar. Locked drawings can still be deleted but they cannot be dragged or resized. A must for Gann tools and key support/resistance levels you keep grabbing by accident when scrolling.

Hotkey Ctrl+Alt+H (Win) / Cmd+Opt+H (Mac) toggles every drawing on and off. Or click "Hide drawings" in the left toolbar's hide-options menu. Useful when you want a clean chart for a screenshot without deleting your annotations.

Open the drawing's settings (double-click it, or click the gear in its floating toolbar), tweak the colors and styles, then click Templates → "Save as default." Every new drawing of that type from now on uses your style. Note: defaults are per-tool, not global — you have to set them individually for trendline, fib, channel, etc.

Right-click the drawing → Clone, or hold Ctrl/Cmd and drag it to make a duplicate. To get a drawing onto a different timeframe of the same symbol, just switch the chart's timeframe — drawings are anchored to bar coordinates, so they stay on the same dates. To get it onto a different chart in a multi-chart layout, enable layout sync (overlapping-squares icon) or "Sync globally" on that specific drawing.

The charting engine, indicators, Pine editor, alerts, and broker integrations are identical. The desktop app adds true multi-monitor support, native OS notifications, color-tagged tabs that link symbols, synced crosshair across windows, and the ability to keep running when your browser crashes. If you live on multiple monitors, the desktop app is meaningfully better than the browser.

Yes — and as of 2024 multi-monitor is free for all plan tiers, including Free. Open new windows with Ctrl/Cmd+N or detach a tab and drag it to another display. Browsers fundamentally cannot do true multi-window with shared state, which is why power users move to the desktop app.

Sign in to the same TradingView account on every device. Watchlists, alerts, and chart layouts sync automatically. Drawings sync if autosave is enabled in chart settings. Some sync features (multiple saved layouts) require a paid plan. If sync seems broken, check that you are on the same account, force-refresh the watchlist panel, and avoid editing the same layout on two devices simultaneously.

Five common causes. Push not enabled in the TradingView app's profile settings; "Notify on App" not ticked when the alert was created; the app not whitelisted in Android battery optimization or Autorun manager (which silently kills the background process); iOS notifications blocked at the OS level for TradingView; or you are signed in to a different account on the phone than the one that owns the alert. Whitelisting from battery optimization is the single most common fix on r/TradingView.

No. The mobile app does not include the Pine editor. The official workaround is to open tradingview.com in a mobile browser (Chrome or Safari) and use the detached editor link, but typing Pine on a phone is genuinely painful. For anything beyond a one-line tweak, wait until you are at a real keyboard.

No — TradingView's own help center says the mobile screener is "not currently supported" on iOS and Android. The workaround is to open the screener via mobile browser at tradingview.com/screener. TradingView has been promising native mobile screener support for years; as of April 2026 it still isn't shipped.

iOS widgets yes — Watchlist, Symbol, and News widgets are available and support iOS 16+ lock-screen placement. Edit them via the home-screen Customise mode. Apple Watch app: no first-party app on the App Store as of April 2026. Some users wire up Watch alerts via push notification mirroring, but there is no native complication.

Connect a broker via the chart's three-dot menu → connect broker. Then tap the Plus button on the price scale to place a pending order, or use the Buy/Sell buttons on the trading panel for market orders. There is no right-click context menu on mobile, so a few advanced order types are easier from desktop.

Yes. Windows, macOS (Intel and Apple Silicon, requires macOS 12 Monterey or newer), and Linux (Debian via .deb package, plus snap and Flathub). System requirements are at tradingview.com/desktop and tend to track the chart engine's RAM appetite — 16GB is recommended for serious users despite TradingView's lower stated minimum.

Recurring complaint in Play Store reviews. The mobile app sits on a system WebView, so an outdated WebView (Android System WebView or iOS Safari) is the most common culprit. Clear the app cache, update the WebView, force-close and reopen, disable battery saver mode, and reinstall as a last resort. Heavy charts with many indicators chew memory faster on mobile than on desktop — pare down indicators if a specific chart consistently freezes.

Honestly, no. Mobile push delivery adds carrier and OS-side latency on top of the alert itself — Reddit reviews report 20-30 second delays from alert fire to phone notification, sometimes more under load. For scalping, use desktop OS notifications, sound alerts, or webhook-driven automation. The mobile app is fine for swing trading and monitoring; it is not the right tool for sub-minute reaction.

Color-tag the tabs that should share a symbol — right-click the tab → pick a color. Tabs with the same color group share their symbol and crosshair. Combined with interval syncing across windows (added in 2024), changing the timeframe in one tab can cascade to its color-linked siblings on the other monitor. This is the "command center" feel that browser tabs cannot match.

Free TradingView accounts get CME Group futures (CME, CBOT, NYMEX, COMEX) delayed by 10 minutes. To get real-time, you have to subscribe separately to the CME real-time bundle inside TradingView — around $7/month at the retail rate. The "FYI for futures traders" warning that goes viral on r/futures every few months is exactly this issue: people place trades against stale prints because they did not realise the chart was 10 minutes behind.

CME bundle (CME, CBOT, NYMEX, COMEX) is around $7/month at the retail rate, billed separately from your TradingView plan. The professional rate is around $548/month — a 78x multiplier driven by exchange-side licensing. CBOE is free at the BZX feed level. NASDAQ TotalView, NYSE/AMEX, and NYSE Arca are separate add-ons; the "US Stock Markets" bundle is roughly $9.95/month.

Pro classification is set by the exchanges, not TradingView. Triggers: trading on behalf of a business entity, being SEC or CFTC registered, working in financial-services data, or performing investment-adviser-like functions. If any of those apply to you, you sign the non-pro declaration at your peril — exchange data fees jump roughly 50-100x. Critically, if you are reclassified as professional later, you are liable retroactively from the start of your subscription. Don't lie on the declaration.

Yes — every TradingView user gets real-time CBOE BZX data for US stocks at no cost, because Cboe doesn't charge per-user fees on BZX. BZX represents roughly 25% of US equity volume, so the prints are real but the tape is thinner than what you would see with a NYSE TotalView subscription. For most retail trading the difference is invisible. Extended hours (pre/post market) is NOT included on the free BZX feed — that requires a paid primary-exchange subscription.

The "1!" suffix means front-month continuous. So ES1! = front-month continuous E-mini S&P 500. ES2! = second-month (the next-out contract). These are synthetic stitched series for charting; when you place an order against ES1!, the actual trade routes to the current front-month contract underneath (e.g., ESM2025 in late spring 2025). Trading 1!/2! orders is supported only for CME and EUREX futures.

Continuous (ES1!) gives you long historical context — usually 15+ years on the major contracts — but has roll discontinuities you have to handle. The specific monthly contract (ESM2025 = June 2025 E-mini S&P) gives you clean prints with no roll gaps but only ~3 months of useful data and dies on expiry. Use continuous for analysis and long-term backtests; use the specific contract for actual order entry close to expiry. Most chartists chart continuous and place orders on the specific underneath.

Volume-based, not calendar-based. The switch happens when the next contract's daily volume statistically exceeds the current one's. In practice this typically begins around 6 business days before the current contract's expiration. So a "rollover" on the chart is not a calendar event you can pin in advance — it's whenever liquidity actually migrates.

Back-adjustment recalibrates historical bars by the price gap created at each contract roll, smoothing the stitched series so moving averages, ATR, and percentage calculations stay sane. Off by default. Toggle it on via the chart settings on continuous symbols, or click the "B-ADJ" button at the bottom-right of the chart. The trade-off: anchored drawings move when prices recalibrate, so re-anchor key levels after switching. Worth it for any indicator-driven analysis.

Forex is decentralised — there is no consolidated tape, so each broker quotes its own bid/ask. FXCM, OANDA, and FOREX.com feeds reflect those individual dealers. ICE feeds (ICEUS, ICE) are composites blended from many contributors and are closer to "interbank reference." Spreads, ticks, and reported volume differ by source. The right answer for charting is "match the feed to the broker you actually trade with so the chart reflects your real fill prices."

The canonical format is EXCHANGE:SYMBOL — NASDAQ:AAPL, BINANCE:BTCUSDT, CME_MINI:ES1!, CRYPTO:BTCUSD (aggregated). Typing just "AAPL" works because TradingView auto-routes to a default exchange (often BATS or BZX for US stocks), but the prefix gives you the exact data source. In Pine Script, syminfo.prefix returns the exchange and syminfo.ticker returns the symbol portion.

Three usual culprits. First: the search modal has filters (exchange, type) that may be silently restricting results — clear them at the top of the search panel. Second: end-of-day-only symbols don't appear in autosuggestions but open if you type the full EXCHANGE:SYMBOL and hit Enter. Third: the symbol may genuinely not be on TradingView — small foreign exchanges, niche OTC tickers, and crypto pools below liquidity thresholds get excluded.

Type the equation directly into the symbol box: AAPL/GOOGL, SPY-QQQ, (AAPL+MSFT+GOOGL)/3. Constants are allowed (MSFT+50). Operators supported: +, −, *, /. Hard limit: 10 unique symbols per expression. Hit Enter and TradingView treats the whole expression as a chartable instrument, which you can then save to a watchlist.

Toggle the "ETH" button at the bottom-right of the chart, but pre/post candles are gated by your data feed. The free CBOE BZX feed is regular hours only — no extended hours candles will show. To see real pre-market and after-hours, subscribe to a primary-exchange data package (NASDAQ Basic, NYSE Arca) or pick a feed that includes ETH. Extended hours only displays on intraday timeframes (less than 1D).

Stock-split adjustment is on by default — that is why historical AAPL doesn't show $400 prices pre-2020. Dividend adjustment is a separate toggle: click the "adj" button at the bottom-right of the chart (blue text = adjusted, black = raw), or open Chart Settings → Symbol tab. Dividend adjustment lowers historical prices by the cumulative dividend amount so total-return performance is comparable to current price.

Plus plan now includes ~6 months of 1-minute history. Premium and Ultimate go meaningfully deeper. For some symbols (major indices, large-cap stocks, top crypto pairs) 1-minute history extends back to 2011 or earlier on the higher tiers. Seconds-based intervals (1s, 5s, 30s) are stored from August 2022 onward — they did not exist before that.

Each crypto exchange's history starts whenever the pair was first listed there. BTCUSD on Binance starts in 2017 because Binance launched then; BTCUSD on Bitstamp goes back further because Bitstamp predates it. To get the deepest combined history, use the aggregated CRYPTO:BTCUSD symbol — TradingView blends data from multiple venues to produce the longest possible series.

Your TradingView plan and your broker's exchange-data permissions are completely independent. Paying for TradingView Premium does not entitle you to real-time data inside the broker's order panel — that comes from the broker's own market-data subscription, billed separately on the broker side. So your TradingView chart can be live while the IBKR or TradeStation panel inside TradingView still shows "delayed." Subscribe to data on both sides if you need real-time on both surfaces.

Each exchange reports its own volume — there is no consolidated tape in crypto. BINANCE:BTCUSDT volume is huge because Binance is the largest venue; COINBASE:BTCUSD volume is much smaller because Coinbase has less share. The aggregated CRYPTO: prefix sums volume across venues. For US stocks, the same effect is smaller but real — BATS/BZX volume is a fraction of NYSE+NASDAQ consolidated volume, which is why CBOE BZX charts can look "thin" relative to a TotalView feed.

Three usual causes. First: too many indicators, drawings, or Pine scripts on a single chart — the WebGL renderer slows down past several hundred drawings. Second: progressive memory bloat after 30+ minutes of use, where a restart "fixes" it for another half hour (classic memory-leak symptom — open a fresh tab). Third: server-side load during US market open (9:20-10:30 AM ET), where drawing sync slows down platform-wide and is not a you-problem. Trim indicators, hard-refresh (Ctrl+Shift+R), and if it persists during open, it is probably TradingView's side.

Drawing sync, alert evaluation, and quote distribution all spike load simultaneously when millions of users hit the platform at 9:30 AM ET. r/TradingView users repeatedly confirm this is server-side: changing browser, machine, internet connection, or hardware does not help. The only mitigation is to do your important setup work before the open and rely on already-loaded charts during the first hour.

Standard four-step fix in order: hard refresh (Ctrl+Shift+R / Cmd+Shift+R), clear browser cache and cookies for tradingview.com, disable browser extensions one at a time (especially ad blockers and privacy extensions), and try a different browser to isolate browser-level vs account-level issues. Around 60% of "TradingView is broken" threads on r/TradingView resolve at one of those four steps.

A single trendline can spike multiple CPU cores during the redraw because the renderer recalculates the visible chart. Drawing 30 fibs and 25 indicators on one chart is genuinely heavy. Intel Mac users report 100% CPU on the web app — that is a known issue and the desktop app is materially better. 8GB RAM works for casual use; serious chartists with multiple monitors and saved layouts should plan for 16GB minimum, 32GB if you live in the platform.

"No data here" or just a spinner — usually a browser cache issue or TradingView server hiccup. Right-click the chart → Clear chart cache. If that fails, hard-refresh, then try incognito to rule out extensions. If multiple symbols and multiple browsers all show blank, it is a TradingView server issue — check the status page and wait. Blank multi-chart panes after the first one is a separate known bug; reopening the layout usually fixes it.

It is a TradingView-side error, not yours. Common appearances: when loading certain studies, when logging into a connected broker, when submitting a support ticket, or when placing an order. There is nothing to fix on your end — wait a few minutes and retry. Recurring "internal server error" on a specific Pine script usually means the script's compute cost exceeded a per-execution budget; in that case, simplifying the script (fewer request.security calls, fewer drawings) helps.

Mac, Windows, and Linux users all hit this occasionally. Try in order: kill the app process and restart, delete the app cache directory (location varies by OS — Application Support on Mac, AppData on Windows, ~/.config/TradingView on Linux), reinstall the app, and check the system requirements page for OS version compatibility. The Linux 3.0.0 release in late 2025 caused mass blank-chart reports; downgrading or upgrading to the next point release fixed it.

Open your ad blocker (uBlock Origin, AdBlock, Brave Shields), find the site list or whitelist setting, and add tradingview.com. The "ad blocker app detected" pop-up shows even when the blocker is set to allow — TradingView checks for the extension's presence, not its rules. Some users disable the extension on tradingview.com entirely as the cleanest fix.

This is the worst-designed flow on the platform. The support ticket form requires you to be logged in, which you cannot do. Workarounds: email [email protected] directly with your username, account email, and proof of identity (last 4 digits of payment card on file, recent login IP, anything that links you to the account). The 2FA reset has no self-serve path — you have to wait for human support. Set a calendar reminder to back up your 2FA seed when you originally enable it, because this is one of the easiest ways to permanently lose access.

Check spam, junk, and promotions folders first — TradingView reset emails frequently land there. If still nothing, try a different email provider (Gmail to Outlook etc.) or wait 5-10 minutes (the reset email is queued, not instant). If it never arrives, the email on the account may be wrong; contact support. r/TradingView has many threads from users whose reset emails simply never arrived — escalating to email support is the fastest path.

Most often this is a 3D-Secure failure or a temporary card hold that the bank shows as "charge" but is not actually settled. Check the bank statement after 3-5 business days — if the charge falls off, it was a hold, not a real charge. If it sticks and you have no subscription, email [email protected] with the bank screenshot and the failed-checkout date. Fixed within a few days in most cases.

You hit your plan's per-chart indicator cap: 2 on Free, 5 on Essential, 10 on Plus, 25 on Premium, 50 on Ultimate. The Free cap dropped from 3 to 2 in late 2023 and is still the most upvoted complaint on r/TradingView about the free tier. Either remove indicators or upgrade. Note: drawing tools (trendlines, fibs from the toolbar, the Anchored VWAP drawing tool) do not count toward this limit.

Pine runtime error: your script's memory or CPU exceeded a per-execution budget. Common triggers: deep [] history references on many series, growing arrays/maps that never trim, more than 40 request.security calls, or thousands of drawing objects. Fixes in order of impact: explicitly set max_bars_back=500, trim arrays, cache request.security results in var variables, raise max_lines_count/max_labels_count/max_boxes_count, and as a last resort use calc_bars_count to limit historical execution.

Most often outdated WebView. The mobile app sits on Android System WebView (Android) or Safari's engine (iOS). Update both your OS and the WebView component, clear the app cache, force-close and reopen, disable battery saver, and reinstall as a last resort. iOS users hitting blank-chart on launch after an update typically fix it by closing the app and reopening; if drawings vanished after update, sign out and back in to force re-sync.

Editing the same layout on two devices simultaneously is the usual cause — the autosave from one session overwrites the other. Other triggers: drawings on indicator sub-panes (RSI pane, MACD pane) get wiped when you hide the indicator; drawings save per-symbol-per-layout, so switching tickers temporarily hides them. Sign out of the older session before working on the newer one, and use "Sync globally" on critical drawings so they travel across symbols and layouts.

Click the time at the bottom-right of the chart and pick the right time zone (or "Exchange" for the symbol's home market). Pine scripts have separate time logic — built-ins like hour, minute, and dayofweek always run in the exchange's time zone regardless of your chart display. Edge cases like daily timestamps showing off-by-one can happen near DST transitions; the chart fixes itself a day later.

For futures, gaps usually mean a contract rollover where back-adjustment is off — turn on B-ADJ to smooth them. For low-volume tickers, missing candles can be genuine — no trades happened in that minute. For most tickers, sporadic gaps mid-session are tick-aggregation glitches that resolve on chart refresh. Persistent gaps on a normally liquid name are worth a support ticket.

A few possibilities. First: your TradingView plan and your exchange data subscription are separate — paying for Premium does not include real-time CME or NYSE data. Second: TradingView's geo-IP check can flag your location as outside the licensed region (typical after travel) and demote the feed to delayed; contact support to reset. Third: the screener and trading panel sometimes use a different data path than the chart, so one can be live while another shows delayed. Verify the exact feed badge ("Real-Time" or a delay indicator) at the top of the chart.

TradingView's brokerage page lists 100+ verified partners. The most-used: Tradovate, AMP/CQG, TradeStation, Interactive Brokers, OANDA, FXCM (region-dependent), Pepperstone, IC Markets, Saxo, Capital.com, tastytrade, Webull, Alpaca, moomoo, Binance, Bybit, OKX, Bitstamp, Coinbase, and Gemini. The list rotates as partnerships come and go — always verify against the broker dropdown on a live chart, not just the marketing page. Brokers NOT natively integrated and that need a webhook bridge: Rithmic, ProjectX/TopstepX, Match-Trader, TradeLocker, most MT4/MT5 brokers, and most prop-firm-specific platforms.

No — TradingView's own Pine FAQ confirms strategies cannot push orders through the native broker panel. The native panel is for manual order entry only. To get fully automated execution from your Pine signal, you have to fire a TradingView alert that emits a JSON payload, and use a webhook bridge (PickMyTrade, TradersPost, etc.) to translate that alert into a real broker order. This is the single most-misunderstood thing on r/algotrading about TradingView automation.

No. The broker panel at the bottom of the chart is a manual order interface — buy, sell, modify, cancel, all by clicking. It does not consume Pine signals and it does not respond to alerts. For anything Pine-driven you need an external bridge that listens to your TradingView webhook and places the order on your behalf via the broker's API.

Native = manual chart trading on a single connected broker, no automation, no Pine-driven execution. Webhook bridge = alert-driven automated execution that works with any broker the bridge supports, including ones TradingView doesn't natively integrate with (Rithmic, ProjectX, TradeLocker, Match-Trader, prop firms). You can use both at the same time: native panel for discretionary clicks, bridge for the systematic Pine strategy. PickMyTrade and similar bridges exist precisely because the native panel cannot automate.

Yes — Tradovate has a free "TradingView add-on" inside the Tradovate platform, and Tradovate also appears in TradingView's broker panel for chart-based manual orders. That covers manual trading. For Pine-driven automation, you still need a webhook bridge — PickMyTrade is the most-used route for Tradovate automation among r/futures traders, partly because Tradovate is the backend for many futures prop firms.

No. Rithmic has no native TradingView panel — Rithmic users must use a bridge. The standard path is TradingView alert → webhook → bridge → Rithmic R|API+ → broker fill. PickMyTrade is one of the few bridges that supports Rithmic directly, which makes it a default choice for Apex (on Rithmic), Tradeify (on Rithmic), and other prop firms running on Rithmic infrastructure.

Depends on which Apex platform your Combine runs on. Apex's Tradovate-hosted accounts work via the Tradovate TradingView add-on for manual trading. Apex Rithmic accounts have no native TradingView path — you need a bridge. For Pine-driven automation on either Apex variant, the standard route is PickMyTrade, which supports both Tradovate and Rithmic and is one of the bridges Apex traders default to on r/propfirm.

Topstep's official help center confirms: TopstepX cannot connect to external charting platforms like TradingView, and custom indicators are not currently available. All new Topstep Combines (post-July 2025) run on TopstepX (a ProjectX-based platform), so they inherit this limitation. Legacy Tradovate-hosted Topstep accounts still work with the TradingView add-on for manual trading. For Pine automation on ProjectX/TopstepX accounts, PickMyTrade supports the ProjectX API directly — it bypasses the missing native integration.

Tradovate-hosted firms (legacy Topstep, Tradeify on Tradovate, MFFU on Tradovate) work via the Tradovate TradingView add-on for manual trading. ProjectX-based firms (TopstepX, new Apex, etc.) do not have a native TradingView panel. Forex prop firms (FTMO, FundedNext) typically run on TradeLocker or Match-Trader, neither of which has native TradingView integration. For Pine-driven automation across the prop ecosystem, PickMyTrade supports 27+ prop firms across all those backends, which is why it has become the default automation layer for funded futures and forex traders.

Yes — IBKR has an official TradingView landing page and shows up in the broker panel for stocks, futures, forex, and options. Manual trading only via the native panel. For Pine-driven automation on IBKR, the path is webhook bridge — PickMyTrade and TradersPost both support IBKR. The IBKR API (TWS/Gateway) is famously complex to drive directly, which is the main reason most TradingView+IBKR automators use a hosted bridge instead of writing their own.

Yes — both Binance (spot + futures) and Bybit (spot, USDT/USDC perps, inverse perps) appear in the TradingView broker panel for manual trading. For Pine-driven automation, crypto traders on r/algotrading still use webhook bridges; PickMyTrade supports both Binance and Bybit, though it is not the dominant lane in crypto (Alertatron and 3Commas have larger crypto-specific share). For futures/prop, PMT is the default; for crypto, evaluate against the alternatives.

Native integrations require a formal partnership: TradingView's REST API spec, legal agreements, regulatory clearance, and engineering work on both sides. Brokers come and go as those partnerships shift — FXCM has been availability-inconsistent in the US, Saxo's status changes by region, smaller regional brokers cycle on and off the list. TradingView lets you upvote requests but the queue moves slowly. A webhook bridge solves this in a single weekend because bridges are partnership-independent — they integrate with the broker's own API directly, not through TradingView.

TradingView's own docs say "stable connection in one tab and to one broker only." So no, not natively in a clean way. Workarounds exist (detached tabs each connected to a different broker), but they are fragile. The proper solution for true multi-broker workflows — running an alert into your live futures account at Tradovate AND your prop firm account at Rithmic AND your equity hedge at IBKR simultaneously — is a webhook bridge that fans out a single alert to multiple broker accounts. PickMyTrade does this routing natively.

Decision tree. Manual discretionary trading on a single broker that has a native panel → native is fine, no bridge needed. Pine-driven automation, multi-account routing, prop firm execution (especially on Rithmic, ProjectX, TradeLocker, Match-Trader), or any broker without a native panel → bridge. Many active traders run both simultaneously — native panel for the manual scalping clicks, PickMyTrade or TradersPost for the systematic Pine strategy that runs in the background.

Not natively. Neither TradeLocker nor Match-Trader has a TradingView broker panel. TradeLocker actually positions itself the other way — it embeds TradingView charts inside the TradeLocker platform, not the reverse. For forex prop firms (FTMO, FundedNext, MyFundedFX, etc.) that issue accounts on those platforms, automated TradingView execution requires a bridge. PickMyTrade supports both TradeLocker and Match-Trader, which makes it a common choice for funded forex traders running Pine strategies.