---
title: "TradingView Placeholder List: All 11 strategy.* Variables"
slug: tradingview-placeholder-list-strategy-variables-explained
date: 2026-09-08
modified: 2026-09-08
author: Bhavishya Goyal
excerpt: ""
meta_description: "TradingView has 11 strategy.* alert placeholders. This TradingView placeholder list explains what each returns and about PickMyTrade JSON."
focus_keyword: tradingview placeholder list
canonical_url: "https://blog.pickmytrade.trade/tradingview-placeholder-list-strategy-variables-explained/"
og_title: "TradingView Placeholder List: All 11 strategy.* Variables"
og_description: "TradingView has 11 strategy.* alert placeholders. This TradingView placeholder list explains what each returns and about PickMyTrade JSON."
og_image: "https://blog.pickmytrade.trade/wp-content/uploads/2026/09/Gemini_Generated_Image_jmbl5jjmbl5jjmbl-1024x572.avif"
schema_type: FAQPage
categories:
  - TradingView
  - Tradingview Strategy
tags: []
reading_time: 15
word_count: 3676
robots: "index, follow"
lang: en-US
---

# TradingView Placeholder List: All 11 strategy.* Variables

**TradingView alert placeholders** are the double-curly-brace tokens, such as `{{close}}`, that TradingView replaces with live values the moment an alert fires. Every strategy alert starts life as a template full of them. When an order fills, TradingView swaps each token for its value and posts the result to your webhook. Get one token wrong and your broker receives the literal text `{{strategy.order.action}}` instead of the word `buy`.

Table of Contents

1. [Where do strategy.* variables sit in the TradingView placeholder list?](https://blog.pickmytrade.trade/#where-do-strategy-variables-sit-in-the-tradingview-placeholder-list)
2. [Which 4 placeholders describe the order that just filled?](https://blog.pickmytrade.trade/#which-4-placeholders-describe-the-order-that-just-filled)
3. [{{strategy.order.action}}](https://blog.pickmytrade.trade/#strategy-order-action)
4. [{{strategy.order.contracts}}](https://blog.pickmytrade.trade/#strategy-order-contracts)
5. [{{strategy.order.price}}](https://blog.pickmytrade.trade/#strategy-order-price)
6. [{{strategy.order.id}} and {{strategy.order.comment}}](https://blog.pickmytrade.trade/#strategy-order-id-and-strategy-order-comment)
7. [The position placeholders: where the strategy stands after the fill](https://blog.pickmytrade.trade/#the-position-placeholders-where-the-strategy-stands-after-the-fill)
8. [{{strategy.position_size}} versus {{strategy.market_position_size}}](https://blog.pickmytrade.trade/#strategy-position_size-versus-strategy-market_position_size)
9. [{{strategy.market_position}} and {{strategy.prev_market_position}}](https://blog.pickmytrade.trade/#strategy-market_position-and-strategy-prev_market_position)
10. [{{strategy.prev_market_position_size}}](https://blog.pickmytrade.trade/#strategy-prev_market_position_size)
11. [How does {{strategy.order.alert_message}} work, and when is it empty?](https://blog.pickmytrade.trade/#how-does-strategy-order-alert_message-work-and-when-is-it-empty)
12. [Where you can set it](https://blog.pickmytrade.trade/#where-you-can-set-it)
13. [Rule 1: other placeholders don’t work inside it](https://blog.pickmytrade.trade/#rule-1-other-placeholders-dont-work-inside-it)
14. [Rule 2: the string is fixed at call time](https://blog.pickmytrade.trade/#rule-2-the-string-is-fixed-at-call-time)
15. [Rule 3: a missing parameter sends an empty string](https://blog.pickmytrade.trade/#rule-3-a-missing-parameter-sends-an-empty-string)
16. [Which placeholder goes in which PickMyTrade JSON field?](https://blog.pickmytrade.trade/#which-placeholder-goes-in-which-pickmytrade-json-field)
17. [Why pyramid stays on and reverse_order_close stays off](https://blog.pickmytrade.trade/#why-pyramid-stays-on-and-reverse_order_close-stays-off)
18. [Keep the quotes around numeric placeholders](https://blog.pickmytrade.trade/#keep-the-quotes-around-numeric-placeholders)
19. [Why does the webhook arrive with literal {{strategy.order.action}} text?](https://blog.pickmytrade.trade/#why-does-the-webhook-arrive-with-literal-strategy-order-action-text)
20. [The seven failures we see most often](https://blog.pickmytrade.trade/#the-seven-failures-we-see-most-often)
21. [When the payload is right but the order still fails](https://blog.pickmytrade.trade/#when-the-payload-is-right-but-the-order-still-fails)
22. [Frequently asked questions](https://blog.pickmytrade.trade/#frequently-asked-questions)
23. [Check three things before a payload goes near a funded account](https://blog.pickmytrade.trade/#check-three-things-before-a-payload-goes-near-a-funded-account)

This guide is the strategy half of the **TradingView placeholder list**. It covers all 11 `strategy.*` variables: what each one returns, the moment it resolves, and which PickMyTrade JSON field it belongs in. The standard and `{{plot}}` families get a short recap and a link to the full reference. The strategy family gets the depth, because it’s where nearly every broken webhook we look at actually broke.

> **Key Takeaways**
> 
> 
> 
> 
> 
> 
> 
> - All 11 `strategy.*` placeholders resolve only in alerts created from a strategy’s order-fill events.
> - `{{strategy.order.action}}` returns `buy` or `sell`, never `close`. Exits arrive as the opposite side.
> - On a reversal, `{{strategy.order.contracts}}` carries the combined size, so one netted order flips the position.
> - `{{strategy.order.alert_message}}` comes back empty from any order call that skipped the parameter.
> - PickMyTrade’s template maps four placeholders (`date`, `data`, `quantity`, `price`) and fixes everything else.

## Where do strategy.* variables sit in the TradingView placeholder list? {#where-do-strategy-variables-sit-in-the-tradingview-placeholder-list}

TradingView’s placeholder list has three families: 12 standard tokens, 20 numbered plot slots, and 11 strategy variables. Only the strategy family knows anything about orders or positions. Only an alert created on a strategy’s order-fill events can fill those values in. The standard family covers the chart itself: `{{ticker}}`, `{{exchange}}`, `{{open}}`, `{{high}}`, `{{low}}`, `{{close}}`, `{{volume}}`, `{{time}}`, `{{timenow}}`, `{{interval}}`, `{{syminfo.currency}}`, and `{{syminfo.basecurrency}}`. The plot family exposes an indicator’s output series as `{{plot_0}}` through `{{plot_19}}`, or by title with `{{plot("Name")}}`. Both families are documented line by line in the [full TradingView placeholder reference](https://docs.pickmytrade.trade/docs/tradingview-plot-placeholder/), so this article won’t repeat them.

Placeholders per family in TradingView alerts

Standard (chart)

12
Plot slots

20
Strategy (strategy.*)

11
Plot slots run {{plot_0}} to {{plot_19}}; {{plot(“Name”)}} reaches the same 20 series by title.

Three placeholder families, and only one of them knows about orders
*Three placeholder families, and only one of them knows about orders*

So what makes the strategy family different? Timing. Standard and plot tokens are read from the chart whenever any alert fires. Strategy tokens are read from the broker emulator at the instant an order fills. That’s why an indicator alert, or a message built inside the `alert()` function, sends them through as plain text.

A useful way to hold all 11 in your head is two questions. What did the order just do? Four `order` tokens answer that. Where does the strategy stand now? Six position tokens answer that.

The eleventh, `{{strategy.order.alert_message}}`, is a pass-through from your Pine code, and it deserves its own section.

## Which 4 placeholders describe the order that just filled? {#which-4-placeholders-describe-the-order-that-just-filled}

![A trader studying a wall-mounted TradingView strategy chart with moving averages, the source of order-fill alerts](https://images.pexels.com/photos/7567522/pexels-photo-7567522.jpeg?auto=compress&cs=tinysrgb&w=1200&fm=webp)

Four of the 11 strategy placeholders describe the order that just executed, and every webhook payload PickMyTrade parses uses at least two of them. They resolve once per fill. A strategy that places an entry and a bracket exit therefore generates two separate alerts with two separate sets of values.

### {{strategy.order.action}} {#strategy-order-action}

`{{strategy.order.action}}` returns the string `buy` or `sell` for the executed order. It never returns `close`. A `strategy.close()` on a long position fires as `sell`, and a `strategy.close()` on a short fires as `buy`. The emulator only knows the side of the order it filled, not your intent behind it.

Does that mean a strategy can’t flatten cleanly through a webhook? No, and this is the part most guides skip. The exit order’s size equals the open position, so a `sell` for one contract while you’re long one contract nets to flat at the broker. PickMyTrade’s strategy template relies on exactly that netting, which is why it never needs a `close` value from a strategy alert.

### {{strategy.order.contracts}} {#strategy-order-contracts}

`{{strategy.order.contracts}}` returns the number of contracts in the executed order, and on a reversal that number already includes the position being closed. Pine’s rule is simple. When an entry fills against an open position in the opposite direction, the emulator adds the position’s size to the new order. Long one contract, call `strategy.entry()` short for one, and a single order for two contracts fills.

That single order produces a single alert with `contracts` equal to 2.

Send it to a futures broker as `sell 2` and the account nets from long one to short one in one step. It’s also why `reverse_order_close` has to stay `false` in a strategy payload, which the JSON section below walks through.

### {{strategy.order.price}} {#strategy-order-price}

`{{strategy.order.price}}` returns the price the emulator filled the order at, and that isn’t always the same number as `{{close}}`. A market order that fills on the next bar’s open usually agrees with `{{close}}` at that tick. A stop or limit exit from `strategy.exit()` fills at the level itself, so the two diverge whenever price gaps through it. That gap is worth watching if you log fills for later analysis, because a strategy whose exits are all stop orders will show a systematic spread between the two tokens.

For PickMyTrade the distinction is informational. Strategy alerts execute as market orders by design, a choice the team explains in [why strategies only support market orders](https://docs.pickmytrade.trade/docs/why-strategies-market-orders-only/). The `price` field only matters if you deliberately switch to limit-order automation.

### {{strategy.order.id}} and {{strategy.order.comment}} {#strategy-order-id-and-strategy-order-comment}

`{{strategy.order.id}}` returns the identifier you passed as the first argument of the order call, and `{{strategy.order.comment}}` returns the `comment` argument. When no comment is set, the comment placeholder falls back to the order ID. In a quickly written script the two often print the same text.

Set the comment explicitly on every order call anyway. It’s the one placeholder whose value you fully control per order. `strategy.exit()` extends that control with `comment_profit`, `comment_loss`, and `comment_trailing` for each leg of a bracket. The practical payoff shows up below, where a comment of `close` can drive the `data` field directly.

> **What we see:** In our experience, the most common misread in support tickets is treating `{{strategy.order.contracts}}` as the position after the fill. It’s the order, not the position. On a reversal it reads 2 while the position reads 1, and a bot that copies it into a manual sizing formula doubles the trade.

## The position placeholders: where the strategy stands after the fill {#the-position-placeholders-where-the-strategy-stands-after-the-fill}

Six of the 11 strategy placeholders describe position state, and all six resolve after the fill. A flattening order therefore reports `flat` and `0`, not the position it just closed. The `prev` pair exists precisely so you can still see what was there a moment earlier.

### {{strategy.position_size}} versus {{strategy.market_position_size}} {#strategy-position_size-versus-strategy-market_position_size}

`{{strategy.position_size}}` is signed: positive when long, negative when short, zero when flat. `{{strategy.market_position_size}}` is the same quantity as an absolute value, so it’s never negative. Which one you want depends on whether the receiving system reads direction from the number or from a separate field.

Signed versus absolute position size

{{strategy.position_size}}

{{strategy.market_position_size}}

+3
+2
+1
0
-1
-2
-3

+2

2
Long 2 contracts
0
0
Flat

-3

3
Short 3 contracts

Same position, two numbers: the signed token dips below zero on a short, the absolute token never does
*Same position, two numbers: the signed token dips below zero on a short, the absolute token never does*

### {{strategy.market_position}} and {{strategy.prev_market_position}} {#strategy-market_position-and-strategy-prev_market_position}

`{{strategy.market_position}}` returns `long`, `flat`, or `short` as a word, and `{{strategy.prev_market_position}}` returns the same word for the state before the fill. Read together, they classify any fill without arithmetic. `flat` to `long` is an entry, `long` to `flat` is an exit, and `long` straight to `short` is a reversal.

### {{strategy.prev_market_position_size}} {#strategy-prev_market_position_size}

`{{strategy.prev_market_position_size}}` returns the absolute size of the position before the fill. Why keep it around? Combine it with `{{strategy.order.contracts}}` and a reversal explains itself. A previous size of 1 against an order of 2 means one contract closed and one opened.

Here’s the full set through a four-order lifecycle on one contract with pyramiding off:

| # | Order call | action | contracts | prev_market_position | prev_market_position_size | market_position | market_position_size | position_size |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | strategy.entry("Long") | buy | 1 | flat | 0 | long | 1 | 1 |
| 2 | strategy.close("Long") | sell | 1 | long | 1 | flat | 0 | 0 |
| 3 | strategy.entry("Short") | sell | 1 | flat | 0 | short | 1 | -1 |
| 4 | strategy.entry("Long") while short | buy | 2 | short | 1 | long | 1 | 1 |

Row 4 is the one to memorize.

One alert, one order of 2 contracts, and every position token already reflects the new long. Nothing in the payload says “reversal” unless you compare the `prev` tokens with the current ones.

## How does {{strategy.order.alert_message}} work, and when is it empty? {#how-does-strategy-order-alert_message-work-and-when-is-it-empty}

![A laptop code editor on a wooden desk, where Pine Script order calls and alert_message strings get written](https://images.pexels.com/photos/34804001/pexels-photo-34804001.jpeg?auto=compress&cs=tinysrgb&w=1200&fm=webp)

`{{strategy.order.alert_message}}` returns whatever string you passed to the `alert_message` parameter of the order call that filled, and Pine has supported it since version 4. If that particular call didn’t set the parameter, the placeholder resolves to an empty string. There’s no default and no warning.

### Where you can set it {#where-you-can-set-it}

The parameter is available on `strategy.entry()`, `strategy.order()`, `strategy.exit()`, and `strategy.close()`. Exits go one step further with `alert_profit`, `alert_loss`, and `alert_trailing`, so each leg of a bracket can carry its own text. A minimal Pine v6 script that tags entries and exits looks like this:

```
//@version=6
strategy("Placeholder demo", overlay = true, default_qty_type = strategy.fixed, default_qty_value = 1)

fast = ta.sma(close, 20)
slow = ta.sma(close, 50)

if ta.crossover(fast, slow)
    strategy.entry("Long", strategy.long, comment = "buy", alert_message = "buy")

if ta.crossunder(fast, slow)
    strategy.close("Long", comment = "close", alert_message = "close")
```

### Rule 1: other placeholders don’t work inside it {#rule-1-other-placeholders-dont-work-inside-it}

Other placeholders are not substituted inside the parameter. Writing `alert_message = "{{close}}"` sends those nine characters as they are, because placeholder replacement happens in the alert dialog’s message box, not inside Pine strings. Dynamic values inside `alert_message` have to be built with `str.tostring()` or `str.format()`.

### Rule 2: the string is fixed at call time {#rule-2-the-string-is-fixed-at-call-time}

This one is rarely written down. The string is fixed at call time, while placeholders resolve at fill time. Your script runs on the close of the signal bar and freezes the `alert_message` text right then. The order fills on the next bar’s open by default. Only then does TradingView compute `{{strategy.order.price}}`.

In practice, `str.tostring(close)` inside the parameter is the signal bar’s close, while `{{strategy.order.price}}` is the actual fill. The gap between them is your slippage, and it’s the gap your backtest never showed you.

> **A pattern worth stealing:** Don’t put the whole JSON payload in `alert_message`. Put only the routing word there and let the dialog’s placeholders do the rest. For example, set `"data": "{{strategy.order.alert_message}}"` in the dialog and `alert_message = "close"` on every exit call. You get an explicit flatten instead of a netted `sell`, and the payload still carries live `contracts` and `timenow` values.

### Rule 3: a missing parameter sends an empty string {#rule-3-a-missing-parameter-sends-an-empty-string}

If one order call in the script lacks the parameter, its alert delivers `"data": ""` and the order is rejected on arrival. There’s no warning in the Strategy Tester, because the tester never sees alert text. Add the parameter to every call, or pass `disable_alert = true` on the orders you want to fill silently.

## Which placeholder goes in which PickMyTrade JSON field? {#which-placeholder-goes-in-which-pickmytrade-json-field}

![Close-up of code parsing JSON fields, like the webhook payload that carries placeholder values to PickMyTrade](https://images.pexels.com/photos/6424583/pexels-photo-6424583.jpeg?auto=compress&cs=tinysrgb&w=1200&fm=webp)

PickMyTrade’s strategy template uses exactly 4 placeholders: `{{timenow}}` for `date`, `{{strategy.order.action}}` for `data`, `{{strategy.order.contracts}}` for `quantity`, and `{{close}}` for `price`. The other 13 of its 17 keys are fixed values you set once, and the dashboard’s Generate Alert button fills them in for you.

Here is the template, trimmed to the fields that matter for placeholder mapping:

```
{
  "symbol": "MNQ",
  "date": "{{timenow}}",
  "data": "{{strategy.order.action}}",
  "quantity": "{{strategy.order.contracts}}",
  "risk_percentage": 0,
  "price": "{{close}}",
  "tp": 0,
  "sl": 0,
  "dollar_tp": 0,
  "dollar_sl": 0,
  "update_tp": false,
  "update_sl": false,
  "token": "your_token_here",
  "pyramid": true,
  "reverse_order_close": false,
  "order_type": "MKT",
  "account_id": "your_account_id"
}
```

| JSON field | Placeholder | Why this one |
| --- | --- | --- |
| date | {{timenow}} | Fire time to the second in UTC, the timestamp PickMyTrade logs for the order |
| data | {{strategy.order.action}} | buy or sell; exits arrive as the opposite side and net at the broker |
| quantity | {{strategy.order.contracts}} | Already includes the flattening portion on a reversal |
| price | {{close}} | Informational under market execution; becomes the limit price only in a limit-order setup |
| symbol | Fixed text such as MNQ | {{ticker}} would send the chart symbol, such as MNQ1!, which then needs mapping |
| token, account_id | Fixed | Generated in the PickMyTrade dashboard, never from the chart |
| pyramid, reverse_order_close | true, false | Lets the broker net the sizes TradingView already computed |

### Why pyramid stays on and reverse_order_close stays off {#why-pyramid-stays-on-and-reverse_order_close-stays-off}

Why those last two flags? Because TradingView has already done the position math. With `pyramid` on and `reverse_order_close` off, PickMyTrade places the order as sent and the broker nets it against whatever is open. Flip `reverse_order_close` to `true` and PickMyTrade closes the opposite position first, then places the full order. Do the arithmetic on row 4 above: close the long, then sell 2, and you’re short 2 instead of short 1.

That flag isn’t wrong. It’s built for indicator alerts, where every signal is a fixed size and nothing upstream tracks position. The [JSON alert configuration reference](https://docs.pickmytrade.trade/docs/tradingview-json-alert-configuration/) lists the defaults for both alert types. The [stacking orders guide](https://docs.pickmytrade.trade/docs/pickmytrade-stacking-orders-json/) covers the pyramid combinations, including the stacking run we tested ourselves, which stacked 11 same-direction entries before anything needed closing.

When each part of the payload gets its value
CALL TIME
FILL TIME

Signal bar
order call runs,
alert_message text
is frozen here

Order fills
next bar open by default,
all strategy.* tokens and
{{timenow}} resolve

Webhook POST
TradingView sends
the finished JSON

PickMyTrade
validates fields,
maps the symbol

Broker
nets order
str.tostring(close) inside alert_message = the signal bar’s close. {{strategy.order.price}} = the fill on the next bar.
The difference between the two is the slippage your backtest never showed you.

Call time versus fill time: the two moments a strategy alert’s values get locked in
*Call time versus fill time: the two moments a strategy alert’s values get locked in*

### Keep the quotes around numeric placeholders {#keep-the-quotes-around-numeric-placeholders}

The template quotes the numeric placeholders, so `quantity` arrives as the string `"2"` rather than the number `2`. PickMyTrade parses both, so keep the quotes. Removing them makes the message invalid JSON on any bar where the placeholder doesn’t resolve. An invalid message fails before it ever reaches the order logic.

Want the complete setup around the payload, from webhook URL to account linking? Our [TradingView to Tradovate webhook guide](https://blog.pickmytrade.trade/tradingview-to-tradovate-webhook-guide-2026-no-code/) covers it end to end, and the [introduction to TradingView alerts](https://blog.pickmytrade.trade/introduction-to-tradingview-alerts-2025-updated-guide/) covers the alert types themselves.

## Why does the webhook arrive with literal {{strategy.order.action}} text? {#why-does-the-webhook-arrive-with-literal-strategy-order-action-text}

![A candlestick chart on a monitor with a hand-drawn projection arrow, a strategy alert that fired with the wrong payload](https://images.pexels.com/photos/5831252/pexels-photo-5831252.jpeg?auto=compress&cs=tinysrgb&w=1200&fm=webp)

Literal placeholder text in a webhook means the alert wasn’t created from a strategy’s order-fill events. It’s the most frequent of the 7 placeholder failures we deal with. TradingView only substitutes `strategy.*` tokens inside strategy alerts. Inside an indicator alert, or inside a message built by the `alert()` function, they pass through untouched. The fix is procedural rather than technical. Open the alert dialog with the strategy selected, set the condition to the strategy name with **Order fills**, or **Order fills and alert() function events**, and paste the JSON into the message box.

### The seven failures we see most often {#the-seven-failures-we-see-most-often}

The rest of the recurring failures cluster into a short list:

| Symptom | Cause | Fix |
| --- | --- | --- |
| Payload contains {{strategy.order.action}} verbatim | Alert created on an indicator condition or from an alert() call | Recreate it on the strategy’s order-fill events |
| "data": "" arrives and the order is rejected | alert_message missing on that order call | Add the parameter to every strategy.* order call, or use disable_alert |
| Alert still sends old values after a script edit | TradingView froze the script at creation time | Delete the alert and create a new one; edits and setting changes never propagate |
| Reversal doubles the position | reverse_order_close set to true with {{strategy.order.contracts}} | Set it to false for strategy alerts and let the broker net |
| Symbol Mapping Not Found | symbol holds {{ticker}} output such as MNQ1! with no mapping | Use a fixed root like MNQ, or map the continuous contract in the dashboard |
| Account id ... not found in user connection | Payload built for an account that isn’t connected | Regenerate the alert with the correct account selected |
| Message rejected as invalid JSON | A comment or ID containing a double quote landed inside a quoted field | Keep IDs and comments to plain letters, digits, and underscores |

Is the strategy itself behaving? A stale alert is the sneakiest of these, because the chart keeps updating while the alert quietly runs last month’s code. TradingView’s own rule is blunt. For any change to a strategy’s settings to reach the alert, delete the alert and create a new one. That applies to inputs and properties, not only to source edits.

### When the payload is right but the order still fails {#when-the-payload-is-right-but-the-order-still-fails}

When the payload looks right and the order still doesn’t land, the problem has usually moved past placeholders. The [alert errors reference](https://docs.pickmytrade.trade/docs/pickmytrade-alert-errors/) lists the exact rejection strings PickMyTrade returns. Our [5-layer fix for alerts that don’t execute trades](https://blog.pickmytrade.trade/tradingview-alerts-not-executing-trades/) works down from TradingView to the broker when nothing lands at all. For exits that misbehave at the Pine level, the [strategy.exit error reference](https://blog.pickmytrade.trade/pine-script-error-reference-strategy-exit-trail_offset/) covers the argument errors that break bracket exits.

## Frequently asked questions {#frequently-asked-questions}

**What is the full TradingView placeholder list?** 

TradingView documents three families. The 12 standard placeholders describe the chart, such as `{{ticker}}` and `{{close}}`. The 20 numbered plot placeholders run from `{{plot_0}}` to `{{plot_19}}`, also reachable by title with `{{plot("Name")}}`. The 11 strategy placeholders only resolve in alerts built on a strategy’s order fills.

 
 
**Does {{strategy.order.action}} ever return “close”?** 

No. It returns only `buy` or `sell`, the side of the order that filled. A `strategy.close()` on a long fires as `sell`. The exit order’s size matches the open position, so sending that `sell` with `{{strategy.order.contracts}}` nets the position to flat at the broker. No separate close command is needed.

 
 
**What’s the difference between {{strategy.position_size}} and {{strategy.market_position_size}}?** 

`{{strategy.position_size}}` is signed, so a short of 3 contracts reads `-3`. `{{strategy.market_position_size}}` is the absolute value, so the same short reads `3`. Both describe the position after the fill, and both read `0` when the strategy is flat. Use the signed token when the receiving system reads direction from the number, and the absolute one when direction travels in a separate field.

 
 
**Can I use {{close}} or {{ticker}} inside alert_message?** 

No. Placeholders are only replaced in the alert dialog’s message box, never inside a Pine string. Inside `alert_message`, build dynamic values with `str.tostring()`. Remember the string is fixed when the order call runs, not when the order fills, so it reflects the signal bar rather than the fill.

 
 
**Do I need to recreate the alert after editing my strategy?** 

Yes. TradingView freezes the script and its settings when the alert is created, so source edits, input changes, and property changes never reach an existing alert. Delete the old alert and create a new one on the strategy’s order-fill events. Then confirm the next payload with a [paper-trading run](https://blog.pickmytrade.trade/tradingview-paper-trading-guide-2025/) before the account goes live.

 
 

## Check three things before a payload goes near a funded account {#check-three-things-before-a-payload-goes-near-a-funded-account}

Eleven placeholders, two questions. The 4 `order` tokens tell you what filled, and the 6 position tokens tell you where the strategy stands.

Then confirm three things before you let the alert run against real money. The alert was built on the strategy’s order-fill events, not on an indicator condition. Every order call in the script sets `alert_message`, or none of them do and you route on `{{strategy.order.action}}` instead. And `reverse_order_close` stays `false`, so the broker nets the size TradingView already computed rather than closing and re-opening on its own.

Get those three right and the rest is arithmetic.

If you’d rather not build the payload by hand, use the Generate Alert button in the PickMyTrade dashboard. It writes the strategy JSON with the right four placeholders and the right two flags already in place. It comes with every plan, including the free trial, and the [pricing page](https://pickmytrade.trade/pages/pricing/) has the current numbers. The [TradingView automation overview](https://pickmytrade.trade/tradingview-automation/) covers what happens after the webhook lands.

_Written by the PickMyTrade Team, who build TradingView-to-broker automation for futures, stocks, and options traders. Questions about a payload that isn’t behaving? Reach us through the [about page](https://pickmytrade.trade/pages/about/) or the [contact page](https://pickmytrade.trade/pages/contact-us/)._

---

**_D_**_**isclaimer:**  
This content is for informational purposes only and does not constitute financial, investment, or trading advice. Trading and investing in financial markets involve risk, and it is possible to lose some or all of your capital. Always perform your own research and consult with a licensed financial advisor before making any trading decisions. The mention of any proprietary trading firms, brokers, does not constitute an endorsement or partnership. Ensure you understand all terms, conditions, and compliance requirements of the firms and platforms you use._

---

ALso Checkout: [Automate TradingView Indicators with Tradovate Using PickMyTrade](https://blog.pickmytrade.trade/automate-tradingview-indicators-with-tradovate-using-pickmytrade/)

For AI tools & developers:[View Markdown →](https://blog.pickmytrade.trade/tradingview-placeholder-list-strategy-variables-explained.md)