TradingView Webhook to Telegram Bot: Get Real-Time Alerts on Your Phone (2026 Setup Guide)

That's when I moved my alerts to Telegram. Telegram messages bypass most "do not disturb" settings, the notification sound is customizable, and I can forward signals to a private group where my trading journal bot also logs entries.

Setting this up took me about 20 minutes. Here's exactly how to do it.

What You Need Before Starting

• A TradingView account on Essential plan or higher (webhooks are not available on the free plan)
• A Telegram account
• About 20 minutes

Step 1: Create Your Telegram Bot With BotFather

Every Telegram bot starts with BotFather — Telegram's official bot that creates other bots.

1. Open Telegram and search for @BotFather

The token looks like this: 7123456789:AAHk3gJdKfZ8x9bWcDeFgHiJkLmNoPqRsT

Step 2: Get Your Telegram Chat ID

Your bot needs to know *where* to send messages. That means getting the numeric chat ID for your personal chat, group, or channel.

For Personal Messages

1. Start a conversation with your new bot — search for its username and press Start

https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates

4. Look for "chat":{"id":123456789} — that number is your chat ID

For a Group Chat

1. Add your bot to the group

For a Channel

1. Add the bot as an administrator to your channel

I use a private group with two members: me and the bot. This way I have a searchable log of every alert, and I can add my spouse or trading partner later without reconfiguring anything.

Step 3: Choose Your Relay Method

Here's the thing TradingView's webhook documentation doesn't make obvious: TradingView webhooks send HTTP POST requests to a URL you specify, but you can't just paste the Telegram API URL directly because TradingView sends the alert message as raw text in the request body, not as a properly formatted Telegram API call.

You need a lightweight relay — something that receives the webhook from TradingView and forwards it to Telegram's sendMessage endpoint.

Here are three options, ranked by simplicity:

Option A: TradingFinder's Free Relay (Easiest — No Code)

TradingFinder built a free relay service specifically for this use case. The TradingView community has a popular indicator called "TradingView Telegram Webhook Alert" by TFlab that generates the webhook URL for you.

1. Go to TradingView → Indicators → search "TradingView Telegram Webhook Alert TFlab"

The downside: you're routing your alerts through a third-party server. For price alerts and signal notifications, this is fine. For sending actual trade execution commands, I'd self-host.

Option B: Cloudflare Workers (Free, 5 Minutes, Your Own Relay)

This is what I use. Cloudflare Workers gives you 100,000 free requests per day — more than enough for trading alerts.

Create a file called worker.js:

export default {
  async fetch(request, env) {
    if (request.method !== "POST") {
      return new Response("Send a POST request", { status: 405 });
    }

    const body = await request.text();
    
    // Parse the incoming message
    // TradingView sends the alert message as plain text in the body
    const message = body.trim();
    
    if (!message) {
      return new Response("Empty message", { status: 400 });
    }

    // Forward to Telegram
    const telegramUrl = `https://api.telegram.org/bot${env.BOT_TOKEN}/sendMessage`;
    
    const response = await fetch(telegramUrl, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        chat_id: env.CHAT_ID,
        text: message,
        parse_mode: "HTML"
      })
    });

    if (response.ok) {
      return new Response("Sent", { status: 200 });
    } else {
      const error = await response.text();
      return new Response(`Telegram error: ${error}`, { status: 502 });
    }
  }
};

Deploy it:

npx wrangler init tv-telegram-relay
# Replace the generated worker.js with the code above
npx wrangler secret put BOT_TOKEN
# Paste your bot token when prompted
npx wrangler secret put CHAT_ID
# Paste your chat ID when prompted
npx wrangler deploy

Your relay URL will be something like https://tv-telegram-relay.your-subdomain.workers.dev — use this as the webhook URL in TradingView.

Option C: Google Apps Script (Free, No Terminal Needed)

If you don't have a Cloudflare account and want something browser-only:

1. Go to script.google.com

function doPost(e) {
  const BOT_TOKEN = "YOUR_BOT_TOKEN";
  const CHAT_ID = "YOUR_CHAT_ID";
  
  const message = e.postData.contents;
  
  const url = `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`;
  
  UrlFetchApp.fetch(url, {
    method: "post",
    contentType: "application/json",
    payload: JSON.stringify({
      chat_id: CHAT_ID,
      text: message,
      parse_mode: "HTML"
    })
  });
  
  return ContentService.createTextOutput("OK");
}

4. Deploy → New Deployment → Web app → Execute as "Me" → Access "Anyone"

Step 4: Configure the TradingView Alert

Now the fun part — connecting TradingView to your relay.

1. Open your chart on TradingView

Basic Alert Message

🔔 USDJPY Alert
Price crossed above 150.000
Time: {{timenow}}

Advanced Alert With Dynamic Placeholders

TradingView supports built-in placeholders that get replaced when the alert fires:

📊 <b>{{ticker}}</b> Alert
Action: {{strategy.order.action}}
Price: {{close}}
Time: {{timenow}}
Exchange: {{exchange}}
Interval: {{interval}}

Here's my actual alert message template for USDJPY momentum signals:

🚀 <b>Signal: {{ticker}}</b>

Direction: {{strategy.order.action}}
Entry Price: {{close}}
Timeframe: {{interval}}
Time: {{timenow}}

Strategy: Momentum Crossover

The tags work because our relay sends messages with parse_mode: "HTML" — Telegram renders them as bold text.

🟢 <b>LONG Signal</b>

Pair: <b>{{ticker}}</b>
Entry: {{close}}
Timeframe: {{interval}} min

📊 Momentum Score: see chart
⏰ {{timenow}}

<i>Auto-generated by TradingView Webhook</i>

// In your worker.js, before sending to Telegram:
let formattedMessage = message;
if (message.toLowerCase().includes("buy")) {
  formattedMessage = "🟢 " + formattedMessage;
} else if (message.toLowerCase().includes("sell")) {
  formattedMessage = "🔴 " + formattedMessage;
}

//@version=6
indicator("Momentum Alert Example", overlay=true)

// Simple momentum crossover
fastMA = ta.sma(close, 10)
slowMA = ta.sma(close, 50)

bullishCross = ta.crossover(fastMA, slowMA)
bearishCross = ta.crossunder(fastMA, slowMA)

// Method 1: alertcondition (older, works with manual alert setup)
alertcondition(bullishCross, "Bullish Crossover", "🟢 BUY Signal on {{ticker}} at {{close}}")
alertcondition(bearishCross, "Bearish Crossover", "🔴 SELL Signal on {{ticker}} at {{close}}")

// Method 2: alert() function (newer, fires automatically from strategy)
if bullishCross
    alert("🟢 BUY Signal on " + syminfo.ticker + " at " + str.tostring(close), alert.freq_once_per_bar_close)

if bearishCross
    alert("🔴 SELL Signal on " + syminfo.ticker + " at " + str.tostring(close), alert.freq_once_per_bar_close)

const chatIds = [env.CHAT_ID_1, env.CHAT_ID_2, env.CHAT_ID_3];

await Promise.all(chatIds.map(chatId =>
  fetch(telegramUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ chat_id: chatId, text: message, parse_mode: "HTML" })
  })
));