How to Sell TradingView Signals
Without Sharing Your Pine Script

You spent months tuning a strategy that actually works. Now you want other traders to pay for access to it — but paying for access means they need your signal, and getting a signal to someone means sending it somewhere. That's the entire problem in one sentence.

Search for how to sell TradingView signals and most of what comes back is video walkthroughs. What's harder to find is a written breakdown of how the different distribution methods trade off code privacy against reach. That's what this post does.

The tension you can't fully avoid

Every monetization method leaks something. A raw .pine file leaks everything — anyone who buys it can read every condition, rename it, and resell it as their own. On the other end, a bare buy/sell signal leaks the least, but even that isn't zero: a patient subscriber who logs enough signals across enough market conditions can eventually guess at pieces of your logic.

The honest goal isn't "leak-proof" — it's picking the method that leaks the least for the amount of manual work you're willing to do. If you're new to writing the strategy itself, our Pine Script beginner guide covers that first step; this post assumes you already have something worth protecting.

Comparing the four ways people actually do this

None of these are wrong choices — they fit different situations. Here's how they stack up on the things that actually matter to a paying subscriber and to you as the author.

Selling the raw script

The most direct option: hand over the .pine file for a one-time fee. It's the easiest to set up — no platform, no subscription billing, just a file transfer. The trade-off is exactly what you'd expect: once it's out, it's out. Nothing stops a buyer from reading it, tweaking a few inputs, and reselling it as a "new" strategy.

This works fine if the value isn't really in secrecy — for example, an educational template meant to be studied, or a simple indicator you're not worried about being copied. It's a poor fit if the entry/exit logic itself is the product.

TradingView's invite-only scripts

TradingView lets you publish a script as invite-only and grant access to specific usernames. The buyer sees your indicator or strategy plotted on their own chart — entries, exits, alerts — but can't open the source. This solves the code-leak problem cleanly.

What it doesn't solve is execution. The buyer still has to watch their chart, see the alert fire, and place the order themselves — or wire it to their own automation. Invite-only access protects your code; it doesn't turn your buyer's setup into a hands-off system.

Telegram or Discord signal groups

A person (usually you) posts "BUY BTC 43,200, SL 42,800" into a group chat as trades happen. No code changes hands, no platform fee, and you can start today with tools you already use.

The costs show up later. There's no built-in way for a prospective subscriber to verify your track record beyond screenshots you choose to post. And because it's manual, subscribers miss trades when they're asleep, slow to react, or just mistype the size — the signal is only as reliable as the human relaying it.

Subscription auto-copy platforms

Your alert fires from your own TradingView strategy and goes to a webhook, which automatically routes an order to every subscriber's own exchange account. Nobody types anything. Nobody sees your chart, your indicators, or your code — only the resulting order.

This is the option with the least manual overhead once it's set up, and the tightest lid on logic leakage of the four. The trade-off is setup complexity: you and your subscribers both need working exchange API keys and a platform to run the fan-out, rather than a group chat you can start in five minutes.

Why a webhook only ever carries "what," never "why"

Here's the technical piece that makes auto-copy distribution privacy-preserving: the message TradingView sends when your alert fires is whatever text you put in the alert box. Nothing else about your chart, your script, or your calculations travels with it.

A typical alert payload looks like this — and that's genuinely the entire message:

{
  "action": "buy",
  "symbol": "BTCUSDT",
  "qty_type": "margin_usdt",
  "qty_value": "500"
}

That's an instruction, not an explanation. It says what to do and how much — nothing about why the strategy decided this was the moment. The Pine Script that generated it never leaves your own TradingView account; the webhook only ever sees its output.

What to sort out before you flip the switch

• Proving performance. Nobody pays for a strategy with zero evidence it works. If you don't have a live track record yet, a simulated one — clearly labeled as such — beats no record at all.
• Pricing. Price against what a subscriber can actually verify today, not against what you believe the strategy is eventually worth. A modest promo price for your first subscribers is easier to defend than a full price with zero reviews behind it.
• Compliance and disclaimers. Charging people to copy your trades can brush up against securities or investment-advice rules depending on where you and your subscribers live. This isn't legal advice — check the regulations that apply to you before you charge anyone, and never promise a return.

If you're still deciding whether building and selling a strategy is worth the effort at all, our guide to how retail traders get started with quant covers the costs and pitfalls of that earlier decision.

How TVSBot handles this

To be upfront about how we fit into this: TVSBot's marketplace is the subscription auto-copy model described above, built around the same principle — your alert fires from your own TradingView account, and the platform fans it out to subscribers without ever exposing your Pine Script.

When you publish a strategy, you set your own monthly price, with an optional promo price for early subscribers. Subscribers never touch their own TradingView — they connect an exchange account, pick a size multiplier and a few risk limits (leverage cap, margin percentage, personal take-profit/stop-loss), and every signal you fire gets routed to their account automatically on the next cycle.

In the platform's current setup, subscription revenue splits 70% to the strategy author and 30% as a platform fee that covers payment processing and the fan-out infrastructure that pushes your signal to every connected subscriber account.

Proving performance before you have subscribers

This is the part worth explaining in more detail, because it's the most useful piece for a new author with no track record yet. From the moment a published strategy fires its first signal, the platform records a simulated entry and exit at that moment's market price — no subscriber funds involved, no capital at risk on your side. Over enough signals, that builds into a real equity curve someone can look at before paying you anything.

Strategies move through three trust tiers based on that record:

Worth being straightforward about where things stand: as of this writing, no strategy on the marketplace has reached the Verified badge yet. If you were hoping to browse a leaderboard of proven performers, it isn't there yet — this is a genuinely new channel, not an established one.

For an author considering publishing today, that's arguably the useful part rather than the drawback. There's no backlog of established sellers to compete with for visibility. The paper-tracked record you start accumulating now is the only thing you can show potential subscribers before you have any — once you do have subscribers and real trades flowing, reaching 50+ live trades while listed for 30+ days is what actually moves a strategy to Verified, and right now nobody is ahead of you on that clock.

If you'd rather have Claude help you turn a strategy idea into working Pine Script before you worry about any of this, our guide to writing Pine Script with Claude covers that earlier step end to end.