17:34
Merge Multiple TradingView Signals using Make.com and place order automatically
Nexus Fission
Overview
This video demonstrates how to combine multiple trading signals from TradingView using Make.com (formerly Integromat) to automate order placement. It covers setting up a data store to manage signals, creating a scenario to receive alerts via webhooks, processing and storing these signals, retrieving them, and applying custom logic (e.g., requiring both signals to confirm a buy or sell) before triggering an order through an HTTP request to a broker like Alpaca. The process involves defining data structures, configuring webhooks, using data store modules for storage and retrieval, implementing conditional logic with routers, and finally connecting to an external API for order execution.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- TradingView's native alert system is limited for combining multiple indicators.
- External tools like Make.com are needed to merge signals and make trading decisions.
- The video will demonstrate storing, retrieving, and processing signals to decide on buy or sell orders.
Understanding the limitations of standard tools and the necessity of automation platforms is crucial for developing more sophisticated trading strategies.
Using Make.com to combine signals from two different TradingView indicators.
- Create a 'Data Store' in Make.com to temporarily hold signal information.
- Define a data structure within the Data Store, using a 'key-value' pair with a 'value' column.
- This allows for storing and retrieving specific signal data using unique keys.
A data store acts as a temporary memory, enabling the automation to track signals over time and make decisions based on accumulated information.
Creating a data store named 'my trading data store' with a 'value' column to store signal details.
- Manually add data to the store using a key (e.g., 'signal one') and a value (e.g., 'buy').
- Test the storage by running the node and verifying the data in the Data Store.
- Retrieve data by using the 'Get a Record' module with the specific key to fetch its value.
Testing individual components like data storage and retrieval manually ensures they function correctly before integrating them into a larger workflow.
Adding a record with key 'signal one' and value 'buy', then retrieving it to confirm the value is 'buy'.
- Set up a webhook in Make.com to receive real-time alerts from TradingView.
- Define the expected data structure for the webhook (e.g., alert name, signal, ticker, price).
- Configure the 'Add a Record' module to save incoming webhook data into the Data Store, using the alert name as the key and the signal as the value.
- Enable 'override' to update the value if a signal with the same key is received again, preventing duplicates.
This step connects the external alert source (TradingView) to the automation platform, allowing dynamic data input.
Receiving a webhook with alert name 'signal one' and signal 'sell', then storing it in the data store, overwriting any previous value for 'signal one'.
- To make a decision, retrieve the stored signals.
- Since Make.com's 'Get a Record' module retrieves one entry at a time, add multiple 'Get a Record' modules for each signal you need to check (e.g., one for 'signal one', one for 'signal two').
- This allows the scenario to access the values of all relevant signals.
Accessing all necessary signals is fundamental for implementing complex trading logic that requires confirmation from multiple sources.
Using two 'Get a Record' modules to retrieve the values for both 'signal one' and 'signal two'.
- Use a 'Router' module to create different paths based on conditions.
- Define rules for entering trades: for example, a 'long' entry if 'signal one' is 'buy' AND 'signal two' is 'buy'.
- Define rules for a 'short' entry if 'signal one' is 'sell' AND 'signal two' is 'sell'.
- This allows for custom trading strategies based on the combined signals.
The router module is the brain of the automation, translating the combined signals into specific trading actions.
Setting up a router where one path triggers a long order if both signal one and signal two are 'buy'.
- Use an 'HTTP' module to send order requests to a broker's API (e.g., Alpaca).
- Configure the HTTP request with the correct URL, method (POST), headers, and payload containing order details (symbol, type, quantity, side).
- This step automates the actual execution of trades based on the decisions made in the previous steps.
This is the final step where the automated logic translates into real-world trading actions, executing orders automatically.
Sending a POST request to the Alpaca API to place a buy order for BTC/USD when the conditions for a long entry are met.
- Set up alerts in TradingView for specific indicators (e.g., Super Trend, B4 indicator).
- Configure TradingView alerts to send data to the Make.com webhook URL.
- Ensure the alert message payload is correctly formatted to match the webhook's expected data structure, including dynamic values like ticker and price.
- Test the end-to-end flow by triggering alerts and observing the scenario execution and order placement.
This integrates the visual trading platform with the automation tool, making the entire system functional from signal generation to order execution.
Creating a TradingView alert for the Super Trend indicator that sends a message to the Make.com webhook, including the ticker symbol and current price.
Key takeaways
- Combining multiple trading indicators requires external automation tools like Make.com.
- Make.com's Data Store module is essential for temporarily storing and managing signal data.
- Webhooks are the primary method for receiving real-time data from platforms like TradingView.
- Conditional logic using routers allows for sophisticated trading strategies based on multiple signals.
- HTTP requests enable direct integration with broker APIs for automated order execution.
- Careful configuration of data structures and payloads is critical for successful automation.
- Testing each component individually and then the end-to-end flow is vital for debugging.
Key terms
Make.com (Integromat)TradingView AlertsWebhookData StoreKey-Value PairScenarioRouter ModuleHTTP RequestAPI IntegrationSignal Merging
Test your understanding
- What is the primary limitation of TradingView's native alert system that necessitates using tools like Make.com?
- How does Make.com's Data Store module facilitate the process of combining multiple trading signals?
- Explain the role of a webhook in connecting TradingView alerts to a Make.com scenario.
- How can a router module be used to implement a trading strategy that requires confirmation from two different signals?
- What is the purpose of using an HTTP request module in this workflow, and what information does it typically send?