How to Connect TradingView Pine Script to Angel One?

28.07.2025
1109

34 min
221

Automating trading strategies has become increasingly accessible, and connecting the analytical power of TradingView’s Pine Script with execution platforms like Angel One is a common goal for sophisticated traders. This article delves into the technical intricacies of establishing such a connection.

Understanding the Need for Connection

TradingView offers an unparalleled environment for charting, strategy development, and backtesting using Pine Script. However, to translate these strategies into live trades, an execution bridge to your broker is essential. Connecting TradingView to Angel One allows for:

Automated Execution: Trigger trades on Angel One directly from Pine Script alerts.
Reduced Latency: Minimize manual intervention and reaction time to market signals.
Systematic Trading: Consistently apply your strategies without emotional bias.
Leveraging Pine Script’s Power: Utilize complex custom indicators and strategies that might not be available directly on broker platforms.

Brief Overview of TradingView Pine Script and Angel One

TradingView Pine Script: A domain-specific programming language designed for creating custom technical indicators and strategies on the TradingView platform. Its strengths lie in its ease of use for financial analysis, extensive built-in functions, and a vast community sharing scripts. Pine Script enables traders to define precise entry, exit, and risk management rules.
Angel One: A prominent Indian stockbroker offering a range of financial services. For our purposes, the key offering is the SmartAPI, Angel One’s set of Application Programming Interfaces that allow developers to build custom trading applications, manage user portfolios, and execute orders programmatically.

Article Objectives and Scope

This article aims to provide a comprehensive guide for intermediate to senior developers and traders on how to connect TradingView Pine Script alerts to Angel One for order execution. We will cover:

Prerequisites and environment setup.
Developing Pine Script strategies optimized for webhook alerts.
Building an intermediary webhook listener service.
Authenticating and interacting with the Angel One SmartAPI.
Key considerations for security, error handling, and optimization.

This guide assumes familiarity with Pine Script fundamentals, basic programming concepts (preferably in Python), and an understanding of API interactions. We will not cover basic Pine Script syntax or an introduction to trading itself.

Prerequisites and Setup

Before diving into development, ensure the following components are in place:

Angel One Account and API Access

An active trading and demat account with Angel One.
SmartAPI Access: You’ll need to register for SmartAPI access through Angel One’s developer portal. This process typically involves creating an app and obtaining an API Key, API Secret, and potentially other credentials. Safeguard these credentials meticulously.

TradingView Account and Pine Script Editor Familiarity

A TradingView account. Note that webhook alert functionality generally requires a paid TradingView plan (Pro, Pro+, or Premium).
Proficiency in using the Pine Script editor, developing, and backtesting strategies.

Setting up a Secure Development Environment (e.g., Python)

An intermediary service is required to receive webhooks from TradingView and communicate with the Angel One API. Python is a popular choice due to its extensive libraries and ease of use for web development and API interactions.

Python Environment: Install a recent version of Python (3.7+ recommended).
Virtual Environments: It’s best practice to use virtual environments (e.g., venv or conda) to manage project dependencies and avoid conflicts.
bash python -m venv my_trading_bridge_env source my_trading_bridge_env/bin/activate # On Linux/macOS # my_trading_bridge_env\Scripts\activate # On Windows

Installing Necessary Libraries

Key Python libraries you’ll likely need:

Angel One SmartAPI SDK: The official Python client library for SmartAPI.
bash pip install smartapi-python
Web Framework: To create the webhook listener (e.g., Flask or FastAPI).
bash pip install Flask # or pip install fastapi uvicorn
Requests (often a dependency): For making HTTP requests, if not handled by the SDK entirely.
bash pip install requests
Always refer to the official Angel One SmartAPI documentation for the latest SDK and authentication procedures.

Developing the Pine Script Strategy with Alert Webhooks

Your Pine Script strategy forms the core logic for generating trading signals. It needs to be configured to send these signals via webhooks.

Designing Your Trading Strategy in Pine Script

Assume you have a strategy. The key is to clearly define entry and exit conditions. For instance, a simple moving average crossover strategy:

//@version=5
strategy("MA Crossover Strategy for Webhooks", overlay=true, pyramiding=0, default_qty_type=strategy.fixed, default_qty_value=1)

// Inputs
fastMA_len = input.int(10, title="Fast MA Length")
_slowMA_len = input.int(20, title="Slow MA Length")

// Calculate MAs
fastMA = ta.sma(close, fastMA_len)
slowMA = ta.sma(close, _slowMA_len)

plot(fastMA, color=color.blue, title="Fast MA")
plot(slowMA, color=color.orange, title="Slow MA")

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

// Strategy Orders
if (longCondition)
    strategy.entry("Long", strategy.long)

if (shortCondition)
    strategy.entry("Short", strategy.short) // Or strategy.close("Long") if it's an exit

// For a more robust system, consider explicit exits:
// if (strategy.position_size > 0 and ta.crossunder(fastMA, slowMA))
//     strategy.close("Long", comment = "Exit Long")
// if (strategy.position_size < 0 and ta.crossover(fastMA, slowMA))
//     strategy.close("Short", comment = "Exit Short")

Key Design Point: Ensure your strategy logic is sound and thoroughly backtested on TradingView before attempting automation. Consider position sizing, risk management (stop-loss, take-profit), and how these will be communicated or managed by your bridge application.

Implementing Alert Conditions Based on Strategy Logic

TradingView alerts can be triggered from strategy.* calls or explicitly using alertcondition() or the alert() function. For strategies, alerts are often configured directly on the chart when adding the strategy.

When using strategy.entry, strategy.exit, or strategy.order, TradingView can generate alerts based on these order fills. You will configure the message of these alerts to be a JSON payload for your webhook.

If using an indicator script, you’d use alert():

//@version=5
indicator("My Indicator Alerts", overlay=true)

longSignal = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
shortSignal = ta.crossunder(ta.sma(close, 10), ta.sma(close, 20))

if longSignal
    alert('{"action": "BUY", "symbol": "' + syminfo.ticker + '", "quantity": 1, "price": ' + str.tostring(close) + ', "passphrase": "YOUR_SECRET_PASSPHRASE"}', alert.freq_once_per_bar_close)

if shortSignal
    alert('{"action": "SELL", "symbol": "' + syminfo.ticker + '", "quantity": 1, "price": ' + str.tostring(close) + ', "passphrase": "YOUR_SECRET_PASSPHRASE"}', alert.freq_once_per_bar_close)

Important: Using alert.freq_once_per_bar_close (or alert.freq_once_per_bar for strategies) is crucial to prevent multiple alerts for the same event on a single bar.

Configuring Webhook URLs for Alerts

Add your Pine Script (strategy or indicator) to a chart.
Click the ‘Alert’ button in TradingView’s top toolbar or right-click on the chart.
Set the ‘Condition’ to your script and the specific event (e.g., ‘Long’, ‘Short’, or your custom alert() calls).
In the ‘Actions’ section, check ‘Webhook URL’.
Enter the publicly accessible URL of your webhook listener service (e.g., https://yourdomain.com/tradingview-webhook or an ngrok URL during development).
Message Body: This is where you craft the JSON payload your server will receive. Use TradingView’s placeholders.

For strategy scripts, you can use placeholders like:
```
{
  "symbol": "{{ticker}}", 
  "exchange": "{{exchange}}",
  "action": "{{strategy.order.action}}", 
  "quantity": "{{strategy.order.contracts}}", 
  "price": "{{strategy.order.price}}", 
  "comment": "{{strategy.order.comment}}",
  "position_size": "{{strategy.position_size}}",
  "market_position": "{{strategy.market_position}}",
  "passphrase": "YOUR_VERY_SECRET_PASSPHRASE_HERE" 
}
```
For indicator scripts using alert(), you construct the JSON string directly in Pine Script as shown in the example above.

Security Note: The passphrase is a simple shared secret for basic authentication of the webhook. Ensure it’s strong and managed securely.

Building the Bridge: Webhook Listener and Order Execution

This intermediary service, typically a small web application, will receive TradingView webhooks and execute trades via the Angel One API.

Creating a Web Server to Receive TradingView Webhooks

Using Python with Flask is a common approach. Below is a conceptual example:

from flask import Flask, request, jsonify
import json
import os # For environment variables

# --- Angel One Integration Placeholder --- 
# from SmartApi import SmartConnect
# Assume Angel One client and session management functions are defined elsewhere
# e.g., get_angel_one_client(), place_angel_order(client, order_details)

app = Flask(__name__)

# Load passphrase from environment variable for security
EXPECTED_PASSPHRASE = os.environ.get("TRADINGVIEW_PASSPHRASE")
if not EXPECTED_PASSPHRASE:
    print("CRITICAL: TRADINGVIEW_PASSPHRASE environment variable not set.")
    # Potentially exit or disable webhook endpoint

# --- Symbol Mapping (Crucial) ---
# TradingView symbols (e.g., NSE:SBIN) need to be mapped to Angel One's instrument tokens and trading symbols.
# This mapping can be complex and might require fetching Angel One's instrument list periodically.
# For simplicity, we'll assume a function get_angel_instrument_details(tv_symbol) exists.

def get_angel_instrument_details(tv_symbol):
    # Placeholder: In a real system, this would look up Angel One's specific symbol token and trading symbol.
    # Example: if tv_symbol == "NSE:SBIN": return {"token": "3045", "trading_symbol": "SBIN-EQ", "exchange": "NSE"}
    # This is highly dependent on Angel One's API and your symbol universe.
    # For NFO, currency, MCX, symbols will be different.
    # You might need to parse tv_symbol (e.g. split by ':')
    parts = tv_symbol.split(':')
    if len(parts) == 2 and parts[0] == "NSE" and parts[1] == "RELIANCE":
        return {"token": "2885", "trading_symbol": "RELIANCE-EQ", "exchange": "NSE", "lot_size": 1}
    if len(parts) == 2 and parts[0] == "NFO" and parts[1] == "NIFTY23AUGFUT": # Example Future symbol
        return {"token": "NFO_TOKEN_XYZ", "trading_symbol": "NIFTY23AUGFUT", "exchange": "NFO", "lot_size": 50}
    # Add more mappings or a dynamic lookup mechanism
    print(f"Warning: No Angel One mapping for symbol {tv_symbol}")
    return None

@app.route('/tradingview-webhook', methods=['POST'])
def tradingview_webhook_receiver():
    if not EXPECTED_PASSPHRASE:
        return jsonify({"status": "error", "message": "Server configuration error: Passphrase not set"}), 500

    try:
        raw_data = request.data.decode('utf-8')
        data = json.loads(raw_data)
    except Exception as e:
        print(f"Error decoding JSON: {e}")
        return jsonify({"status": "error", "message": "Invalid JSON payload"}), 400

    print(f"Received webhook: {data}")

    # Validate passphrase
    if data.get("passphrase") != EXPECTED_PASSPHRASE:
        print("Unauthorized: Invalid passphrase")
        return jsonify({"status": "error", "message": "Unauthorized"}), 401

    # Parse signal from TradingView
    tv_symbol = data.get("symbol") # e.g., "NSE:SBIN"
    action = str(data.get("action", "")).upper() # "BUY", "SELL"
    quantity_str = data.get("quantity")

    try:
        quantity = int(float(quantity_str)) # TradingView might send quantity as string or float
    except (ValueError, TypeError):
        print(f"Invalid quantity: {quantity_str}")
        return jsonify({"status": "error", "message": f"Invalid quantity: {quantity_str}"}), 400

    # --- Angel One Specific Logic ---
    instrument_details = get_angel_instrument_details(tv_symbol)
    if not instrument_details:
        msg = f"Symbol {tv_symbol} not found in Angel One mapping."
        print(msg)
        return jsonify({"status": "error", "message": msg}), 400

    angel_token = instrument_details["token"]
    angel_trading_symbol = instrument_details["trading_symbol"]
    exchange = instrument_details["exchange"]
    # Potentially adjust quantity based on lot size for derivatives
    # if exchange == "NFO": quantity *= instrument_details.get("lot_size", 1) 

    order_type = "MARKET" # Or determine from webhook payload if you pass it
    product_type = "INTRADAY" # Or "DELIVERY", "MARGIN", etc. - configure as needed

    # This is where you would call your Angel One order placement function
    # Example placeholder:
    # success, order_id_or_error = place_angel_order(
    #     angel_token=angel_token,
    #     trading_symbol=angel_trading_symbol,
    #     transaction_type=action, # "BUY" or "SELL"
    #     quantity=quantity,
    #     order_type=order_type,
    #     product_type=product_type,
    #     exchange=exchange
    # )

    # Mock response for now
    success = True 
    order_id_or_error = f"mock_order_for_{action}_{quantity}_{angel_trading_symbol}"
    print(f"Mock Order: {action} {quantity} of {angel_trading_symbol} ({angel_token}) on {exchange}")

    if success:
        return jsonify({"status": "success", "message": "Order signal processed", "order_details": order_id_or_error}), 200
    else:
        return jsonify({"status": "error", "message": "Failed to place order", "details": order_id_or_error}), 500

# if __name__ == '__main__':
#     # For production, use a proper WSGI server like Gunicorn or Waitress
#     # For development with Flask's built-in server:
#     # Ensure your machine/firewall allows inbound connections on this port
#     # If running locally for testing with TradingView cloud, use ngrok or similar tunneling service
#     app.run(host='0.0.0.0', port=5000, debug=True)

Deployment Note: For live trading, this server must be deployed on a reliable host (e.g., VPS, cloud platform like Heroku, AWS EC2, Google Cloud Run) and be publicly accessible via HTTPS. For local testing, tools like ngrok can expose your local server to the internet temporarily.

Parsing Webhook Data and Validating the Signal

As shown in the Python example:

Parse JSON: Convert the incoming request body from JSON string to a Python dictionary.
Validate Source: The primary validation method shown is checking a shared passphrase. More advanced methods could include IP whitelisting (if TradingView provides static IPs for webhooks, which they generally don’t for all users) or more complex signature schemes if you can control the payload more granularly (less common with standard TV alerts).
Extract Key Information: Pull out symbol, action, quantity, price (if limit order), etc.
Data Sanitization: Convert data types (e.g., quantity to integer) and validate values.

Authenticating with Angel One API

This is a critical step and requires careful handling of your API credentials. You’ll typically use the Angel One SmartAPI Python SDK.

# (Conceptual - to be integrated into your main application flow)
# from SmartApi import SmartConnect
# import os

# ANGEL_API_KEY = os.environ.get("ANGEL_API_KEY")
# ANGEL_CLIENT_CODE = os.environ.get("ANGEL_CLIENT_CODE")
# ANGEL_PASSWORD = os.environ.get("ANGEL_PASSWORD")
# ANGEL_TOTP_SECRET = os.environ.get("ANGEL_TOTP_SECRET") # Or handle TOTP generation

# global smart_api_client # Manage client instance appropriately
# smart_api_client = None

# def initialize_angel_session():
#     global smart_api_client
#     smart_api_client = SmartConnect(api_key=ANGEL_API_KEY)

#     # Generate TOTP (this part needs a library like pyotp if using TOTP secret)
#     # import pyotp
#     # totp = pyotp.TOTP(ANGEL_TOTP_SECRET).now()

#     # Simplified login - actual TOTP might require a different flow or manual input first time
#     # The SmartAPI documentation should be consulted for the correct session generation method.
#     # It might involve redirection or a different sequence of calls.
#     try:
#         # The parameters and method for generateSession can change. REFER TO DOCUMENTATION.
#         # It's common for brokers to require a one-time token generation (often manual) then use refresh tokens.
#         data = smart_api_client.generateSession(ANGEL_CLIENT_CODE, ANGEL_PASSWORD, "YOUR_GENERATED_TOTP") # Replace with actual TOTP

#         if data['status'] and data['data']['jwtToken']:
#             jwt_token = data['data']['jwtToken']
#             refresh_token = data['data']['refreshToken']
#             feed_token = smart_api_client.getfeedToken() # if needed

#             # Securely store these tokens (e.g., in memory, a secure database, or cache)
#             # For subsequent calls, you'd use these tokens without re-logging in until they expire.
#             print("Angel One session initialized successfully.")
#             # smart_api_client.setAccessToken(jwt_token) # Or similar, depending on SDK
#             # smart_api_client.setRefreshToken(refresh_token)
#             return True
#         else:
#             print(f"Angel One login failed: {data.get('message', 'Unknown error')}")
#             return False
#     except Exception as e:
#         print(f"Error during Angel One session generation: {e}")
#         return False

# Call initialize_angel_session() once at startup or when needed.
# Handle token expiry and refresh logic.

Authentication Flow: Angel One’s SmartAPI typically uses API keys and may involve an OAuth-like flow or TOTP for session generation. Session tokens (JWT, refresh tokens) are then used for subsequent API calls. These tokens have an expiry and need to be managed (refreshed or regenerated).
Always refer to the latest official Angel One SmartAPI documentation for accurate authentication steps and SDK usage.

Executing Orders Through Angel One API based on TradingView Signals

Once authenticated, you use the SDK methods to place orders.

# (Conceptual - to be integrated with the authenticated smart_api_client)

# def place_angel_order(client, angel_token, trading_symbol, transaction_type, quantity, order_type, product_type, exchange, price=0.0):
#     if not client:
#         return False, "Angel One client not initialized."

#     try:
#         order_params = {
#             "variety": "NORMAL", # Or "AMO", "STOPLOSS", "ROBO"
#             "tradingsymbol": trading_symbol, # e.g., "SBIN-EQ"
#             "symboltoken": angel_token, # Angel One's instrument token
#             "transactiontype": transaction_type, # "BUY" or "SELL"
#             "exchange": exchange, # "NSE", "BSE", "NFO", "MCX", "CDS"
#             "ordertype": order_type, # "MARKET", "LIMIT", "STOPLOSS_LIMIT", "STOPLOSS_MARKET"
#             "producttype": product_type, # "DELIVERY", "INTRADAY", "MARGIN", "CARRYFORWARD", "COVER", "BRACKET"
#             "duration": "DAY", # Or "IOC"
#             "quantity": str(quantity) # Ensure quantity is string as per some broker API requirements
#         }
#         if order_type == "LIMIT" or order_type == "STOPLOSS_LIMIT":
#             order_params["price"] = str(price)

#         # If stoploss order, trigger_price might be needed
#         # if order_type in ["STOPLOSS_LIMIT", "STOPLOSS_MARKET"]:
#         #     order_params["triggerprice"] = str(trigger_price_value) 

#         order_id = client.placeOrder(order_params)
#         if order_id:
#             print(f"Order placed successfully with Angel One. Order ID: {order_id}")
#             # Angel One's placeOrder might return more detailed response, parse as needed.
#             return True, order_id
#         else:
#             # The SDK might raise an exception on failure, or return a specific error structure.
#             # This part needs to align with how smartapi-python handles errors.
#             print(f"Failed to place order with Angel One. Response: {order_id}") # Log the actual response
#             return False, "Failed to place order (check logs for details)"

#     except Exception as e:
#         # Catch specific exceptions from the SmartAPI library if possible
#         print(f"Exception placing Angel One order: {e}")
#         return False, str(e)

Critical Mapping: The symbol from TradingView (e.g., NSE:SBIN) needs to be accurately mapped to Angel One’s symboltoken and tradingsymbol format. This usually involves fetching an instrument master list from Angel One and creating a lookup mechanism in your bridge application. This mapping is vital and a common source of errors.

Security, Error Handling, and Optimization

Building a reliable trading bridge requires robust practices in these areas.

Implementing Robust Security Measures

API Key Protection: Store Angel One API keys, secrets, and your webhook passphrase as environment variables or using a secure secrets management system. Never hardcode them in your script.
HTTPS: Ensure your webhook listener is served over HTTPS to encrypt data in transit between TradingView and your server.
Webhook Authentication: Use the shared passphrase. For higher security, consider request signing if you can customize the TradingView payload further (usually not possible with standard alerts).
Server Security: Secure the server hosting your bridge application (firewall, regular updates, minimal privileges).
Session Token Management: Securely store and manage Angel One session/refresh tokens. Avoid logging sensitive token information unless in a highly secure, debug-only mode.

Error Handling and Logging

Comprehensive try-except Blocks: Wrap all external calls (API requests, file I/O) and critical logic sections.
Detailed Logging: Implement structured logging (e.g., using Python’s logging module).
- Log incoming webhook data (potentially redacted for sensitive info in production).
- Log authentication attempts and outcomes.
- Log parameters sent for order placement and the full response from Angel One.
- Log all errors with timestamps, context, and stack traces.
Alerting for Failures: Set up notifications (e.g., email, SMS via a service) for critical failures like repeated API authentication errors, consistent order placement failures, or if the bridge application crashes.
Idempotency: Consider how to handle potential duplicate webhook signals (e.g., if TradingView retries). This might involve checking current positions or recent orders before placing a new one, though this adds complexity.

Rate Limiting and API Usage Optimization

Respect API Limits: Be aware of Angel One’s API rate limits (requests per second/minute for login, order placement, data fetching). Implement client-side rate limiting or queuing if your strategy generates signals too frequently.
Efficient Session Management: Reuse valid session tokens. Implement proper refresh token logic to minimize full login procedures.
Pine Script Alert Frequency: Configure your Pine Script alerts judiciously (alert.freq_once_per_bar_close or similar) to avoid bombarding your webhook listener and the Angel One API.
Batching (If Applicable): While order execution is usually singular, if you have other API interactions (e.g., fetching multiple data points), batch them where possible.

Backtesting and Performance Monitoring

Thorough Pine Script Backtesting: Utilize TradingView’s backtesting engine extensively to validate your strategy’s historical performance before automating it.
Paper Trading: Before committing real capital, run your integrated system in a paper trading mode if Angel One provides such an API endpoint, or by logging intended trades without actual execution. This tests the entire pipeline.
Live Monitoring: Once live, continuously monitor:
- Execution Slippage: Difference between expected price (from TradingView signal) and actual fill price.
- API Error Rates: Track any errors from the Angel One API.
- System Uptime: Ensure your bridge application is running reliably.
- Strategy Performance: Compare live P&L against backtested expectations.
Iterative Refinement: Be prepared to debug, refine your Pine Script strategy, and improve your bridge application based on live performance and encountered issues.

Connecting TradingView to Angel One is a powerful way to automate your trading. However, it involves multiple complex components and requires careful development, rigorous testing, and ongoing maintenance. Prioritize security and robust error handling throughout the process.

Risk Warning

Code example is for educational purposes only and is not financial advice. Automated trading carries substantial risk of loss. Test thoroughly in a demo environment before considering live implementation. Past performance does not guarantee future results. Trade at your own risk and never risk more than you can afford to lose.