To send a Pine Script trading signal to Interactive Brokers (IBKR) API, you need a bridge between TradingView (Pine Script) and IBKR API. Since TradingView doesn’t support direct execution via brokers, you can use webhooks and a Python script to execute trades.

Steps to Automate Pine Script Signals to IBKR

1. Create a Pine Script Strategy that sends alerts via webhooks.
2. Set Up a Webhook Receiver (Flask or FastAPI) to listen for TradingView alerts.
3. Use Python (IBKR API - ib_insync) to place orders in Interactive Brokers.

Step 1: Pine Script - Sending Webhook Signals

Modify your Pine Script strategy to send alerts:

//@version=5
strategy("Webhook Signal", overlay=true)

// Example Buy and Sell Conditions
longCondition = ta.crossover(ta.sma(close, 10), ta.sma(close, 50))
shortCondition = ta.crossunder(ta.sma(close, 10), ta.sma(close, 50))

if longCondition
 strategy.entry("Buy", strategy.long)
 alert("BUY", alert.freq_once_per_bar_close)

if shortCondition
 strategy.close("Buy")
 alert("SELL", alert.freq_once_per_bar_close)

Alert Webhook Message Format (JSON)

When setting an alert, use this custom message format:

{
 "symbol": "AAPL",
 "side": "BUY",
 "quantity": 10
}

Step 2: Webhook Receiver (Python - Flask)

Create a Python server to receive alerts from TradingView.

from flask import Flask, request, jsonify
import asyncio
from ib_insync import *

app = Flask(__name__)

# Connect to IBKR Gateway or TWS
ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1) # Paper Trading Port: 7497

@app.route('/webhook', methods=['POST'])
def webhook():
 data = request.json
 print("Received signal:", data)

 if data and "symbol" in data and "side" in data and "quantity" in data:
 symbol = data["symbol"]
 side = data["side"]
 quantity = int(data["quantity"])

 # Create IBKR order
 contract = Stock(symbol, "SMART", "USD")
 ib.qualifyContracts(contract)

 order = MarketOrder("BUY" if side == "BUY" else "SELL", quantity)
 trade = ib.placeOrder(contract, order)

 return jsonify({"message": "Order sent to IBKR", "trade_id": trade.order.orderId}), 200

 return jsonify({"error": "Invalid request"}), 400

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

Step 3: Set Up TradingView Webhook

1. In TradingView, go to Alerts → Webhook URL.
2. Use the Flask server’s public URL (via ngrok or a cloud server).
3. Example Webhook URL:

   http://your-server-ip:5000/webhook
   

Step 4: Run the Python Webhook Server

Install dependencies and run the server:

pip install flask ib_insync
python webhook_server.py

Step 5: Connect to IBKR & Place Orders

• Run IB Gateway or TWS on port 7497 (paper) or 7496 (live).
• Ensure IBKR API settings allow connections.
• Monitor logs to confirm trades.

Enhancements

✅ Add Stop-Loss & Take-Profit logic.
✅ Implement WebSocket updates for real-time order tracking.
✅ Extend with options trading (e.g., buying options contracts).

Here’s a complete end-to-end program to execute a trade for Microsoft (MSFT) in Interactive Brokers (IBKR) when a signal is received from TradingView via Webhook.

🔹 Overview

1. Pine Script: Sends a webhook alert with a JSON payload when a trade signal occurs.
2. Python Webhook Server (Flask): Listens for alerts from TradingView.
3. IBKR API (ib_insync): Places a trade for MSFT based on the received signal.

Step 1: Pine Script Strategy (TradingView)

This Pine Script sends webhook alerts when the 50-day SMA crosses the 200-day SMA.

//@version=5
strategy("MSFT Trade Signal", overlay=true)

// Define Moving Averages
fastMA = ta.sma(close, 50)
slowMA = ta.sma(close, 200)

// Buy & Sell Conditions
longCondition = ta.crossover(fastMA, slowMA)
shortCondition = ta.crossunder(fastMA, slowMA)

if longCondition
 strategy.entry("Buy", strategy.long)
 alert('{"symbol": "MSFT", "side": "BUY", "quantity": 5}', alert.freq_once_per_bar_close)

if shortCondition
 strategy.close("Buy")
 alert('{"symbol": "MSFT", "side": "SELL", "quantity": 5}', alert.freq_once_per_bar_close)

➡️ TradingView Alert Settings:

• Set alert condition: MSFT Trade Signal
• Choose Webhook URL:

  http://your-server-ip:5000/webhook

• Message Format (Custom JSON):

{
 "symbol": "MSFT",
 "side": "BUY",
 "quantity": 5
}

Step 2: Python Webhook Server (Flask)

This Python script listens for TradingView alerts and places trades in IBKR using

ib_insync

from flask import Flask, request, jsonify
import asyncio
from ib_insync import *

# Initialize Flask app
app = Flask(__name__)

# Connect to IBKR API
ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1) # Use 7496 for live trading

@app.route('/webhook', methods=['POST'])
def webhook():
 """Receive webhook signals and execute trades in IBKR"""
 data = request.json
 print("Received TradingView Signal:", data)

 if data and "symbol" in data and "side" in data and "quantity" in data:
 symbol = data["symbol"]
 side = data["side"]
 quantity = int(data["quantity"])

 # Create IBKR stock contract
 contract = Stock(symbol, "SMART", "USD")
 ib.qualifyContracts(contract)

 # Define order type (Market)
 order_type = "MKT"
 order = MarketOrder("BUY" if side == "BUY" else "SELL", quantity)

 # Execute order
 trade = ib.placeOrder(contract, order)
 print(f"Order placed: {side} {quantity} {symbol}")

 return jsonify({"message": "Order sent to IBKR", "order_id": trade.order.orderId}), 200

 return jsonify({"error": "Invalid request"}), 400

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

Step 3: Running the Python Server

1️⃣ Install dependencies:

pip install flask ib_insync

2️⃣ Run the Flask webhook server:

python webhook_server.py

3️⃣ Start IBKR TWS or IB Gateway, ensure:

• Enable API Access in IBKR.
• Port is set to 7497 (for paper trading).

Step 4: Placing Trades Automatically

• When the 50-SMA crosses above the 200-SMA, TradingView sends a webhook alert.
• The Python server receives the alert and places a market order for MSFT in IBKR.
• Check TWS Activity Log for confirmation.

✅ Enhancements

• 🔹 Stop-Loss & Take-Profit Orders:

  stop_loss = StopOrder("SELL", quantity, 390.0, parentId=trade.order.orderId) # Example SL at $390
  ib.placeOrder(contract, stop_loss)
  

• 🔹 Trailing Stop Orders for better risk management.
• 🔹 Logging System to store trade execution history.