Pine Script to Trading Bot

→

→

→

TradingView (Signal Source)

Runs Pine Script strategy on their servers. Monitors conditions and triggers alerts. Sends webhook POST requests with alert message content.

Webhook Server (Middleware)

Receives HTTP requests from TradingView. Parses and validates signal data. Translates signals into exchange orders. Handles errors and logging.

Exchange API (Execution)

Receives order requests from your server. Executes trades on the market. Returns order status and fill information for position tracking.

// Pine Script v5 Strategy with Webhook Alerts
//@version=5
strategy("MA Crossover Bot", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// Strategy Parameters
fastLength = input.int(10, "Fast MA Length")
slowLength = input.int(30, "Slow MA Length")
secretToken = input.string("your_secret_token_here", "Webhook Secret")

// Calculate Indicators
fastMA = ta.sma(close, fastLength)
slowMA = ta.sma(close, slowLength)

// Entry Conditions
longCondition = ta.crossover(fastMA, slowMA)
shortCondition = ta.crossunder(fastMA, slowMA)

// Execute Strategy
if (longCondition)
    strategy.entry("Long", strategy.long)
    
if (shortCondition)
    strategy.close("Long")

// Alert Messages with JSON Format
alertLongMessage = '{"action": "buy", "symbol": "' + syminfo.ticker + '", "secret": "' + secretToken + '", "price": ' + str.tostring(close) + ', "time": "' + str.tostring(time) + '"}'

alertExitMessage = '{"action": "sell", "symbol": "' + syminfo.ticker + '", "secret": "' + secretToken + '", "price": ' + str.tostring(close) + ', "time": "' + str.tostring(time) + '"}'

// Trigger Alerts
if (longCondition)
    alert(alertLongMessage, alert.freq_once_per_bar_close)
    
if (shortCondition)
    alert(alertExitMessage, alert.freq_once_per_bar_close)

// Plot Indicators
plot(fastMA, "Fast MA", color=color.blue)
plot(slowMA, "Slow MA", color=color.red)

Use Bar Close Signals

alert.freq_once_per_bar_close prevents multiple alerts from the same signal and ensures confirmed data.

Include Secret Token

Validate webhooks with a secret only you and your server know to prevent unauthorized signals.

JSON Format

Structure alert messages as JSON for reliable parsing on your webhook server.

Include All Data

Pass symbol, action, price, and timestamp so your server has complete context for execution.

# webhook_server.py
from flask import Flask, request, jsonify
import json
import os
from datetime import datetime
from exchange_client import execute_trade  # Your exchange module

app = Flask(__name__)

# Load secret from environment variable
WEBHOOK_SECRET = os.environ.get('WEBHOOK_SECRET', 'your_secret_token')

@app.route('/webhook', methods=['POST'])
def handle_webhook():
    try:
        # Parse JSON payload
        data = request.get_json()
        
        # Validate secret token
        if data.get('secret') != WEBHOOK_SECRET:
            log_request(data, 'UNAUTHORIZED')
            return jsonify({'error': 'Unauthorized'}), 401
        
        # Extract trade parameters
        action = data.get('action')  # buy or sell
        symbol = data.get('symbol')
        price = data.get('price')
        
        # Validate required fields
        if not all([action, symbol]):
            return jsonify({'error': 'Missing required fields'}), 400
        
        # Log the signal
        log_request(data, 'RECEIVED')
        
        # Execute trade on exchange
        result = execute_trade(
            symbol=symbol,
            side=action,
            order_type='market'
        )
        
        log_request(data, f'EXECUTED: {result}')
        
        return jsonify({
            'status': 'success',
            'order_id': result.get('order_id')
        }), 200
        
    except Exception as e:
        log_request({}, f'ERROR: {str(e)}')
        return jsonify({'error': str(e)}), 500

def log_request(data, status):
    timestamp = datetime.now().isoformat()
    print(f"[{timestamp}] {status}: {json.dumps(data)}")

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

HTTPS Required

TradingView only sends webhooks to secure HTTPS endpoints. Use Let’s Encrypt for free SSL certificates or deploy behind a reverse proxy like nginx.

High Availability

Your server must be running 24/7 to receive alerts. Use process managers like systemd or PM2, and consider redundant deployments.

Fast Response

Respond quickly to TradingView requests. Execute trades asynchronously if needed to prevent webhook timeouts on long-running operations.

# exchange_client.py
import os
from binance.client import Client
from binance.exceptions import BinanceAPIException

# Load credentials from environment
API_KEY = os.environ.get('BINANCE_API_KEY')
API_SECRET = os.environ.get('BINANCE_API_SECRET')

client = Client(API_KEY, API_SECRET)

def execute_trade(symbol, side, order_type='market', quantity=None):
    """
    Execute a trade on Binance
    
    Args:
        symbol: Trading pair (e.g., 'BTCUSDT')
        side: 'buy' or 'sell'
        order_type: 'market' or 'limit'
        quantity: Order quantity (optional, uses account balance if None)
    """
    try:
        # Get account balance if quantity not specified
        if quantity is None:
            quantity = calculate_position_size(symbol, side)
        
        # Execute market order
        if side.lower() == 'buy':
            order = client.order_market_buy(
                symbol=symbol,
                quantity=quantity
            )
        else:
            order = client.order_market_sell(
                symbol=symbol,
                quantity=quantity
            )
        
        return {
            'success': True,
            'order_id': order['orderId'],
            'filled_qty': order['executedQty'],
            'avg_price': order['fills'][0]['price'] if order['fills'] else None
        }
        
    except BinanceAPIException as e:
        return {
            'success': False,
            'error': str(e),
            'error_code': e.code
        }

def calculate_position_size(symbol, side):
    """Calculate position size based on account balance"""
    account = client.get_account()
    
    if side.lower() == 'buy':
        # Get USDT balance for buying
        usdt_balance = next(
            (float(b['free']) for b in account['balances'] 
             if b['asset'] == 'USDT'), 0
        )
        # Calculate quantity based on current price
        ticker = client.get_symbol_ticker(symbol=symbol)
        return round(usdt_balance / float(ticker['price']), 6)
    else:
        # Get base asset balance for selling
        base_asset = symbol.replace('USDT', '')
        return next(
            (float(b['free']) for b in account['balances'] 
             if b['asset'] == base_asset), 0
        )

Secret Token Validation

Include a secret token in every alert message. Your server rejects any webhook without a valid token, preventing unauthorized signal injection.

API Key Restrictions

Create API keys with minimal permissions, only trading enabled. Disable withdrawals. IP whitelist to your server’s address only.

Position Limits

Implement maximum position sizes in your server logic. Prevent a runaway strategy or malicious signals from over-trading your account.

Rate Limiting

Limit webhook requests per time period. Prevents denial of service and catches strategies generating excessive signals.

import time
from functools import wraps

# Retryable error codes
RETRYABLE_ERRORS = [-1001, -1003, -1015]  # Network, rate limit errors

def retry_on_failure(max_retries=3, base_delay=1):
    """Decorator for retry logic with exponential backoff"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                    
                except Exception as e:
                    last_exception = e
                    error_code = getattr(e, 'code', None)
                    
                    # Check if error is retryable
                    if error_code not in RETRYABLE_ERRORS:
                        raise  # Don't retry permanent errors
                    
                    # Exponential backoff
                    delay = base_delay * (2 ** attempt)
                    print(f"Retry {attempt + 1}/{max_retries} after {delay}s")
                    time.sleep(delay)
            
            raise last_exception
        return wrapper
    return decorator

@retry_on_failure(max_retries=3)
def execute_trade_with_retry(symbol, side, quantity):
    """Execute trade with automatic retry on transient failures"""
    return execute_trade(symbol, side, quantity=quantity)

class CircuitBreaker:
    """Circuit breaker to halt trading on repeated failures"""
    
    def __init__(self, failure_threshold=5, reset_timeout=300):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.last_failure_time = None
        self.is_open = False
    
    def record_failure(self):
        self.failure_count += 1
        self.last_failure_time = time.time()
        
        if self.failure_count >= self.failure_threshold:
            self.is_open = True
            print("CIRCUIT BREAKER OPEN - Trading halted!")
    
    def can_execute(self):
        if not self.is_open:
            return True
        
        # Check if reset timeout has passed
        if time.time() - self.last_failure_time > self.reset_timeout:
            self.is_open = False
            self.failure_count = 0
            return True
        
        return False

Permanent Errors (Don’t Retry)

• • Insufficient funds
• • Invalid symbol/parameters
• • Authentication failed
• • Order quantity too small

Transient Errors (Retry)

• • Network timeout
• • Rate limit exceeded
• • Exchange maintenance
• • Server overloaded

Local State Tracking

Maintain position records in your server updated on each order fill. Track quantity, average entry price, and realized P&L for each symbol.

Exchange Sync

Periodically query exchange balances and open orders. Compare against local state and reconcile differences with alerts or automatic corrections.

Strategy Isolation

Use separate sub-accounts or clear tagging to isolate positions by strategy. Prevents interference between multiple automated systems.

Troubleshooting Common Issues

Advanced Alert Patterns

Advanced Alert with Dynamic Parameters

// Advanced alert with complete trade parameters
atrValue = ta.atr(14)
stopLossPrice = close - (atrValue * 2)
takeProfitPrice = close + (atrValue * 3)
positionSize = (strategy.equity * 0.02) / (atrValue * 2)

advancedAlert = '{
    "action": "buy",
    "symbol": "' + syminfo.ticker + '",
    "secret": "' + secretToken + '",
    "entry_price": ' + str.tostring(close) + ',
    "stop_loss": ' + str.tostring(stopLossPrice) + ',
    "take_profit": ' + str.tostring(takeProfitPrice) + ',
    "position_size": ' + str.tostring(positionSize) + ',
    "atr": ' + str.tostring(atrValue) + ',
    "timeframe": "' + timeframe.period + '"
}'

if (longCondition)
    alert(advancedAlert, alert.freq_once_per_bar_close)

Monitoring and Logging

Scaling Multiple Strategies