How to Filter Securities from Particular Exchanges to Create a Custom Stock Screener in Pine Script

Overcoming Challenges in Building a Custom Pine Script Stock Screener

Have you ever wondered if it's possible to fetch securities from a specific exchange in Pine Script, filter them through custom conditions, and then display them on a chart? You're not alone! Many developers and traders have attempted to crack this idea, only to face limitations within Pine Script’s built-in functionality. 🤔

While Pine Script excels at applying technical indicators and visualizations, creating a stock screener to work dynamically on specific exchanges isn’t a native feature. However, with the right coding logic and creativity, you can work around these constraints. The challenge lies in understanding how to retrieve and process security data effectively.

In my personal journey, I faced similar roadblocks. For example, when I tried to create a screener for tech stocks from a specific exchange, I quickly realized that Pine Script lacks the ability to directly query all securities from an exchange. This required out-of-the-box thinking and combining external data processing with Pine Script capabilities. 💻

This article dives into the core challenges of implementing this custom functionality, especially addressing the initial step of fetching securities. Together, we’ll explore whether this ambitious plan is feasible and uncover practical workarounds to bring your screener to life. 🚀

Building a Custom Stock Screener with Pine Script and External Tools

The scripts presented earlier aim to solve the problem of creating a custom stock screener in Pine Script, overcoming the inherent limitations of the platform. The first script works entirely within Pine Script, leveraging arrays to manually manage a list of ticker symbols. It uses the `array.new_string()` and `array.push()` commands to dynamically populate this list. Once the tickers are defined, the script employs `request.security()` to fetch data for each symbol, enabling real-time filtering based on predefined conditions such as volume thresholds. By iterating over the array, the script identifies and highlights the tickers that meet the criteria directly on the chart using `label.new()`. This approach is simple but manual, requiring ticker input within the script itself. 🚀

The second script takes a more advanced route by combining JavaScript for data aggregation and Pine Script for visualization. JavaScript is used to interact with an external API, fetching securities data dynamically based on the exchange specified. The `axios.get()` command retrieves data, and the `response.data.filter()` function applies filters such as volume. This allows for real-time, programmatic control over the securities selection process. The filtered tickers are saved using `fs.writeFileSync()` to a file, which Pine Script can later read and use for visualization. This method streamlines the process but requires a two-step workflow involving external tools. 🤔

The Python-based solution takes a similar hybrid approach, utilizing Python's robust libraries to fetch and process data from APIs. The script defines a function `fetch_securities()` that uses Python's `requests` library to make API calls and filters the securities based on volume thresholds. The tickers are then written to a file, much like in the JavaScript solution, but with Python's straightforward syntax. This data can be imported into Pine Script for final visualization. Python’s flexibility and ease of use make it an excellent choice for backend processing in this setup, especially when dealing with large datasets or complex filters. 💡

In essence, these solutions demonstrate how to bridge the gap between Pine Script’s charting strengths and its limitations in data retrieval. Whether using pure Pine Script or integrating external tools like JavaScript or Python, the key lies in leveraging optimized methods for data filtering and visualization. By employing commands such as `request.security()` in Pine Script or `axios.get()` in JavaScript, developers can build powerful and customized screeners tailored to their unique needs. The combination of tools not only expands Pine Script’s capabilities but also ensures a more efficient and scalable approach to securities analysis. 🚀

// Step 1: Define security list (manual input as Pine Script lacks database access)
var securities = array.new_string(0)
array.push(securities, "AAPL") // Example: Apple Inc.
array.push(securities, "GOOGL") // Example: Alphabet Inc.
array.push(securities, "MSFT") // Example: Microsoft Corp.

// Step 2: Input filter criteria
filter_criteria = input.float(100, title="Minimum Volume (in millions)")

// Step 3: Loop through securities and fetch data
f_get_filtered_securities() =>
    var filtered_securities = array.new_string(0)
    for i = 0 to array.size(securities) - 1
        ticker = array.get(securities, i)
        [close, volume] = request.security(ticker, "D", [close, volume])
        if volume > filter_criteria
            array.push(filtered_securities, ticker)
    filtered_securities

// Step 4: Plot filtered securities on the chart
var filtered_securities = f_get_filtered_securities()
for i = 0 to array.size(filtered_securities) - 1
    ticker = array.get(filtered_securities, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

// JavaScript Code: Fetch and filter securities from an API
const axios = require('axios');
async function fetchSecurities(exchange) {
    const response = await axios.get(`https://api.example.com/securities?exchange=${exchange}`);
    const filtered = response.data.filter(security => security.volume > 1000000);
    return filtered.map(security => security.ticker);
}
// Save tickers to a file for Pine Script
const fs = require('fs');
fetchSecurities('NASDAQ').then(tickers => {
    fs.writeFileSync('filtered_tickers.txt', tickers.join(','));
});

// Pine Script Code: Import and visualize filtered securities
// Load tickers from an external source
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")

// Plot the tickers on the chart
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

# Python Code: Fetch securities and write filtered data to a file
import requests
def fetch_securities(exchange):
    response = requests.get(f'https://api.example.com/securities?exchange={exchange}')
    data = response.json()
    return [sec['ticker'] for sec in data if sec['volume'] > 1000000]

tickers = fetch_securities('NASDAQ')
with open('filtered_tickers.txt', 'w') as file:
    file.write(','.join(tickers))

// Pine Script Code: Visualize pre-filtered data
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

Customizing Pine Script Screeners for Enhanced Functionality

One crucial aspect of building a stock screener in Pine Script is understanding its limitations in accessing data directly from exchanges. While Pine Script can handle advanced calculations and chart overlays, it doesn't natively support retrieving a complete list of securities from an exchange. To address this, developers often combine Pine Script with external data sources. For instance, using APIs like Alpha Vantage or Quandl can help retrieve data, which can then be processed for conditions like volume thresholds, RSI values, or moving average crossovers. This approach allows traders to incorporate data-driven insights into their strategies. 📊

Another technique is utilizing Pine Script's security function creatively. While it is traditionally used for pulling data across timeframes for a specific symbol, some developers utilize it to pull metrics from multiple predefined tickers. This method involves setting up an array of tickers, iterating through them, and dynamically updating the chart based on the conditions met. Though not dynamic for new tickers, this method works well for predefined watchlists or popular indices. 💡

To ensure your screener is effective, it’s essential to optimize conditions for filtering. For example, adding rules like “Only display tickers with a volume greater than 1M and a closing price above the 50-day SMA” can make a screener actionable. With such rules, visual aids like colored labels or plot markers help identify potential candidates quickly. By combining Pine Script’s features with external data handling, traders can craft highly customized screeners tailored to their unique trading strategies. 🚀