Integrating TradingView Plot Placeholder with PickMyTrade

14 min read

Introduction #

In this section, we’ll explore how to use named plot placeholders like plot(“title”) when automating your TradingView strategies with PickMyTrade. This feature allows you to reference specific indicator values by their titles instead of the generic plot_0, plot_1, etc., making your alerts clearer and easier to manage. For more details on this feature, refer to the official TradingView blog post: Introducing Variables in Alerts.

Step 1: Add the Bollinger Bands Indicator #

  1. Open TradingView and go to your chart.
  2. Click on Indicators and search for Bollinger Bands.
  3. Add the Bollinger Bands indicator to your chart.

Step 2: Open the Pine Script Code #

To understand the plots available in the Bollinger Bands indicator, let’s take a look at its Pine Script code:

//@version=6

indicator(shorttitle="BB", title="Bollinger Bands", overlay=true, timeframe="", timeframe_gaps=true)

length = input.int(20, minval=1)

maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])

src = input(close, title="Source")

mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")

ma(source, length, _type) =>

    switch _type

        "SMA" => ta.sma(source, length)

        "EMA" => ta.ema(source, length)

        "SMMA (RMA)" => ta.rma(source, length)

        "WMA" => ta.wma(source, length)

        "VWMA" => ta.vwma(source, length)

basis = ma(src, length, maType)

dev = mult * ta.stdev(src, length)

upper = basis + dev

lower = basis - dev

offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)

plot(basis, "Basis", color=#2962FF, offset = offset)

p1 = plot(upper, "Upper", color=#F23645, offset = offset)

p2 = plot(lower, "Lower", color=#089981, offset = offset)

fill(p1, p2, title = "Background", color=color.rgb(33, 150, 243, 95))

In this script, three plots are defined:

  • Basis
  • Upper
  • Lower

These are the titles we’ll use in our placeholders.

Step 3: Creating an Alert #

  • Purpose: Alerts enable TradingView to monitor your chart and send instructions to PickMyTrade when conditions are met, using named labels like {{plot(“Basis”)}}, {{plot(“Upper”)}}, and {{plot(“Lower”)}}.
  • Instructions:
    1. Access Alerts: Click the clock icon with a plus (+) at the top-right or select “Alerts” from the top menu (highlighted in red) and click “Create alert.”
  1. Set Condition: In the “Condition” dropdown (choose “BB (20, SMA, close, 2)” and select a trigger like “Price” at 21,338.75.
  1. Add Message with Placeholders: In the “Message” section, click “Add Placeholder,” go to “Plots,” and select {{plot(“Basis”)}}, {{plot(“Upper”)}}, or {{plot(“Lower”)}}. Example: “Buy at {{close}} with TP at {{plot(“Upper”)}} and SL at {{plot(“Lower”)}}.”
  1. Activate Bollinger Bands: Ensure Bollinger Bands is on your chart. Click “Indicators” (third screenshot, highlighted in red) and select “Bollinger Bands” from “Favorites” or “Technicals.”
  2. Save Alert: Review and click “Create” to activate. The alert will send to PickMyTrade when triggered.

Step 4: Using Named Placeholders in PickMyTrade #

When creating alerts for PickMyTrade, you no longer have to use the generic plot_0, plot_1 placeholders. Instead, use the clearer named placeholders. For example:

  • Stop Loss: {{plot(“Lower”)}}
  • Take Profit: {{plot(“Upper”)}}

This makes your alerts more readable and reduces the chance of errors.

Example: Stop Loss, Take Profit, and Breakeven Using plot(“title”) #

When setting up alerts in PickMyTrade, if your Stop Loss / Take Profit / Breakeven Type is set to Price, you’ll need to use TradingView variables for automatic price entry.

Stop Loss (Auto-Filled Price): Enter the stop loss price from your TradingView indicator.

  • Using numbered placeholders: {{plot_1}}
  • Example: If Stop Loss is 21,691, enter {{plot_1}} when creating the alert.
  • Using named placeholders: {{plot(“Lower”)}}
  • Example: If Stop Loss is 21,691, enter {{plot(“Lower”)}}.

Take Profit (Auto-Filled Price): Enter the take profit price from your TradingView indicator.

  • Using numbered placeholders: {{plot_2}}
  • Example: If Take Profit is 22,091, enter {{plot_2}} when creating the alert.
  • Using named placeholders: {{plot(“Upper”)}}
  • Example: If Take Profit is 22,091, enter {{plot(“Upper”)}}.

#

How the JSON Works and Interacts with TradingView #

When an alert triggers in TradingView, the JSON message is sent to PickMyTrade’s webhook API. Let’s break down what each part of this JSON does:

{

  "symbol": "NQ",                // The trading symbol, e.g., Nasdaq futures

  "date": "{{timenow}}",         // Timestamp of the alert

  "data": "buy",                 // The type of order (buy/sell)

  "quantity": 10,                // Number of contracts to trade

  "risk_percentage": 0,          // Risk percentage, set to 0 if not using risk-based sizing

  "price": "{{close}}",          // Price at the time of the alert

  "gtd_in_second": 0,            // Good-till-date in seconds, 0 for no expiration

  "tp": "{{plot(\"Upper\")}}",   // Take profit price, pulled from the indicator’s named plot

  "percentage_tp": 0,            // Take profit as a percentage, set to 0 if using a fixed price

  "dollar_tp": 0,                // Take profit in dollar terms, set to 0 if not using this

  "sl": "{{plot(\"Lower\")}}",   // Stop loss price, pulled from the indicator’s named plot

  "percentage_sl": 0,            // Stop loss as a percentage

  "dollar_sl": 0,                // Stop loss in dollar terms

  "trail": 0,                    // Trailing stop amount (0 if not using)

  "trail_stop": 0,               // Trailing stop price

  "trail_trigger": 0,            // Price at which trailing stop activates

  "trail_freq": 0,               // Frequency of trailing stop updates

  "update_tp": false,            // Whether to update take profit after order execution

  "update_sl": false,            // Whether to update stop loss after order execution

  "breakeven": 0,                // Breakeven point, if applicable

  "token": "tr41f3653d565f1aadbe8d", // API token for authentication

  "pyramid": false,              // Whether to allow multiple positions in the same direction

  "reverse_order_close": true,   // Whether to close positions in reverse order

  "order_type": "MKT",           // Order type, "MKT" for market orders

  "multiple_accounts": [

    {

      "token": "tr41f3653d565f1aadbe8d",

      "account_id": "FFFF",

      "risk_percentage": 0,

      "quantity_multiplier": 1

    }

  ]

}

This JSON takes indicator values from TradingView (like stop loss and take profit) and sends them directly to PickMyTrade, which then pushes the order to your Tradovate account.

Why Named Placeholders (plot(“title”)) Are Better #

Using named placeholders offers several benefits, as also highlighted in TradingView’s official blog post:

  1. Clarity: Named placeholders like {{plot(“Upper”)}} and {{plot(“Lower”)}} clearly show what each value represents. You no longer have to guess whether {{plot_1}} is your stop loss or take profit.
  2. Fewer Errors: When you modify your indicator — by adding, removing, or reordering plots — the numbered placeholders (plot_0, plot_1) can shift. This can lead to incorrect stop loss or take profit levels. Named placeholders stay tied to their specific titles, so your alerts always remain accurate.
  3. Easier Maintenance: If someone else views your TradingView alerts — or if you return to them later — named placeholders make it easy to understand each value without having to dig into the script.
  4. Better Automation: When linking TradingView alerts to PickMyTrade, named placeholders ensure your automated trades use the correct data, reducing the risk of incorrect order execution.

Implementing a Trading Plan (Strategies) with PickMyTrade #

Overview #

A strategy functions as an automated trading assistant, making buy or sell decisions based on market conditions you define. Unlike indicators that only display lines, strategies actively manage trades and can be linked to PickMyTrade for execution. #

1. Open TradingView #

  • Log in to your TradingView account and open the chart for the asset you want to trade.

2. Adding MACD Strategy from Indicators #

If you want to use a built-in MACD strategy (no custom script needed), follow these steps:

  1. Click on the “Indicators” button (the “fx” icon at the top of the chart).
  2. Search for “MACD” in the search bar.
  3. Select the MACD indicator from the list of results.

This will add the MACD indicator to your chart. You can then access the settings (by clicking the gear icon next to the indicator) to modify the parameters.

However, if you want to add a MACD-based strategy that includes buy/sell signals, you’ll need to use Pine Script.

3. Add Custom MACD Pine Script Strategy #

If you’d like to add your own custom MACD strategy using Pine Script, here’s how you can do it:

  • Open the Pine Script Editor:
    • In TradingView, go to the bottom of the screen and click on the “Pine Editor” tab to open the editor.
  • Create a New Strategy:
    • In the Pine Script Editor, click the “New” button (usually on the top left).
    • Select “Strategy” from the dropdown menu. This allows you to write a strategy that can generate buy and sell signals.
  • Enter the Custom MACD Pine Script Code:

    Now, paste the following code into the Pine Script editor. This is a simple MACD-based strategy:
//@version=6

strategy("MACD Strategy", overlay=true)

fastLength = input(12)

slowlength = input(26)

MACDLength = input(9)

MACD = ta.ema(close, fastLength) - ta.ema(close, slowlength)

aMACD = ta.ema(MACD, MACDLength)

delta = MACD - aMACD

if (ta.crossover(delta, 0))

    strategy.entry("MacdLE", strategy.long, comment="MacdLE")

if (ta.crossunder(delta, 0))

    strategy.entry("MacdSE", strategy.short, comment="MacdSE")

//plot(strategy.equity, title="equity", color=color.red, linewidth=2, style=plot.style_areabr)

4. Add the Strategy to the Chart #

  • Once you’ve pasted the Pine Script, click Add to Chart (at the top of the Pine Editor).
  • If the script is valid, the strategy will be applied to your chart, and you’ll see buy/sell signals based on the MACD.

Step 2: Create an Alert for Your Strategy #

Once your strategy is on the chart, you can set up alerts to be notified or trigger external actions (like sending a message to PickMyTrade). Here’s how:

  1. Create an Alert:
    • Right-click anywhere on the chart and select Add Alert.
    • Alternatively, you can click on the Alerts icon (the bell) on the right toolbar.
  1. Set the Alert Condition:
    • In the Condition section, select your strategy from the drop-down menu.
  • You can choose to trigger the alert on Order Fills (when an entry or exit happens) or use Alert Function Calls for custom conditions.
  1. Define Alert Message:
    • In the Message section, you can reference TradingView placeholders to include relevant information about the alert, like:
      • {{strategy.order.action}}: The action (buy/sell) based on the strategy.
      • {{strategy.position_size}}: The current position size.
      • {{strategy.position_avg_price}}: The average entry price.
      • You can also customize it further with any other placeholders or custom text to fit your needs.
  1. Alert Frequency:
    • You can choose Once Per Bar, Once Per Bar Close, or Only Once for how often the alert should be triggered.
  2. Set Alert Notifications:
    • Choose how you want to be notified (email, SMS, pop-up, or webhook URL).

Step 3: Connecting TradingView Alerts to PickMyTrade #

After creating the alert, you can link TradingView to PickMyTrade to automate the execution of trades. Here’s how you can send the alert to PickMyTrade using a webhook.

  1. Webhook URL Setup:
    • In TradingView, when setting up your alert, under the Actions section, check the Webhook URL box.
    • In the Webhook URL field, enter the webhook URL provided by PickMyTrade (e.g., https://api.pickmytrade.com/alert).

Create JSON Message for PickMyTrade: When an alert is triggered, TradingView will send the following JSON message to PickMyTrade:

{

  "symbol": "NQ",                // The trading symbol (e.g., Nasdaq Futures).

  "date": "{{timenow}}",         // Timestamp of the alert.

  "data": "{{strategy.order.action}}", // The action (buy/sell) based on strategy.

  "quantity": "{{strategy.order.contracts}}", // Number of contracts to trade.

  "risk_percentage": 0,          // Risk percentage, 0 means no risk-based sizing.

  "price": "{{close}}",          // Price when the alert is triggered.

  "tp": 0,                       // Take-profit price (0 means no take-profit set).

  "percentage_tp": 0,            // Take-profit as a percentage (0 means no percentage used).

  "dollar_tp": 0,                // Take-profit in dollar terms (0 means no set dollar profit).

  "sl": 0,                       // Stop-loss price (0 means no stop-loss set).

  "dollar_sl": 0,                // Stop-loss in dollar terms (0 means no dollar limit).

  "percentage_sl": 0,            // Stop-loss as a percentage (0 means no percentage used).

  "trail": 0,                    // Trailing stop amount (0 means no trailing stop).

  "trail_stop": 0,               // Trailing stop price (0 means not set).

  "trail_trigger": 0,            // Price where trailing stop activates (0 means not set).

  "trail_freq": 0,               // Frequency of trailing stop updates (0 means not set).

  "update_tp": false,            // Whether to update take-profit after order execution.

  "update_sl": false,            // Whether to update stop-loss after order execution.

  "breakeven": 0,                // Breakeven point (0 means not set).

  "token": "tr41f3653d565f1aadbe8d", // API token for authentication.

  "pyramid": true,               // Whether to allow stacking multiple trades in the same direction.

  "reverse_order_close": false,  // Whether to close trades in reverse order.

  "multiple_accounts": [         // Allows applying the trade to multiple accounts.

    {

      "token": "tr41f3653d565f1aadbe8d", // Extra account access key.

      "account_id": "tr41f3653d565f1ad", // Account ID.

      "risk_percentage": 0,        // Risk percentage for this account (0 means fixed quantity).

      "quantity_multiplier": 1     // Multiplies trade quantity for this account (1 = same).

    }

  ]

}

Key Parameters: #

  • symbol: The asset being traded (e.g., Nasdaq Futures).
  • date: The timestamp when the alert is triggered.
  • data: Buy or sell action based on the strategy.
  • quantity: The number of contracts or units to trade.
  • risk_percentage: The risk percentage (if set, will influence position sizing).
  • price: The price when the alert was triggered.
  • stop-loss and take-profit: Can be specified to control risk.
  • token: PickMyTrade API token for authentication.
  1. Send the Alert:
    • When the alert is triggered in TradingView, it will send the JSON message to the PickMyTrade API, automatically executing the trade based on your strategy’s logic.

Key Considerations #

  • Real-time Bars: Strategies and alerts are executed on the close of real-time bars unless you set calc_on_every_tick=true in your strategy. This ensures accurate backtesting and signal generation.
  • Order vs. Alert Calls: You can choose to trigger alerts either on order fill events (e.g., when a trade is executed) or through alert() calls for custom warnings or conditions.
  • Bar Confirmation: Alerts will only trigger when both barstate.isrealtime and barstate.isconfirmed are true, meaning the bar must be closed and confirmed before the alert can be sent.

Additional Resources #

For more on TradingView strategies and alerts, check out the official documentation:

This ensures your strategy alerts are accurate, flexible, and fully integrated with PickMyTrade.

Table Of Contents