Building an Automated Stock Momentum Screening System with Polygon API and Python: Real-time Data-driven Investment Strategy

Do you want to automate your investment decisions by building a real-time stock data-driven momentum screening system? This guide provides a step-by-step approach to building a system that collects real-time data using Polygon API and Python, calculates momentum indicators, and identifies investment opportunities. Through this system, you can make data-driven strategic investment decisions and save time and effort.

1. The Challenge / Context

As an individual investor, analyzing vast amounts of stock data in real-time and making investment decisions based on momentum is extremely challenging. Traditional investment methods are time-consuming, susceptible to emotional biases, and may lack objective, data-driven analysis. Especially to respond to rapid market changes, an automated analysis system based on real-time data is essential. This system helps reduce information overload and efficiently identify potential investment opportunities.

2. Deep Dive: Polygon API

Polygon API is a powerful API that provides real-time stock market data, historical data, and company information. Compared to other APIs, Polygon API offers the following advantages:

Real-time Data Provision: Provides accurate real-time data with low latency, supporting quick decision-making.
Extensive Data Coverage: Offers data for various financial instruments, including not only the US stock market but also cryptocurrencies and foreign exchange.
Ease of Use: Designed as a RESTful API, making it easy to use with various programming languages.
Reasonable Pricing: Offers various pricing plans, allowing individual investors to institutional investors to choose a suitable plan.

Key endpoints include:

/v2/ticks/{stockTicker}/{date}: Provides real-time trade history (tick data) for a specific stock ticker on a given date.
/v2/aggs/ticker/{stockTicker}/range/{multiplier}/{timespan}/{from}/{to}: Provides OHLCV (Open, High, Low, Close, Volume) data for a specific period. Essential for momentum calculation.
/v3/reference/tickers: Provides basic company information such as stock ticker, company name, and sector.

3. Step-by-Step Guide / Implementation

Now, let's look at the steps to build an automated stock momentum screening system using Polygon API and Python in detail.

Step 1: Obtain Polygon API Key

Sign up on the Polygon.io website and get an API key. You can start with a free plan and upgrade to a paid plan as needed. It is recommended to securely store your API key in environment variables or a configuration file.

Step 2: Python Environment Setup

Ensure Python 3.7 or higher is installed. Install the necessary libraries:

pip install requests pandas python-dotenv

requests: Used to send API requests.
pandas: Used for data analysis and manipulation.
python-dotenv: Used to manage environment variables like API keys.

Step 3: Set Environment Variables

Create a `.env` file and store your Polygon API key:

POLYGON_API_KEY=YOUR_POLYGON_API_KEY

Load the `.env` file in your Python code:

from dotenv import load_dotenv
import os

load_dotenv()
POLYGON_API_KEY = os.getenv("POLYGON_API_KEY")

if POLYGON_API_KEY is None:
    raise ValueError("Polygon API key not found in environment variables.")

Step 4: Define Data Collection Function

Define a function to fetch stock data using the Polygon API:

import requests
import pandas as pd
from datetime import datetime, timedelta

def get_stock_data(ticker, from_date, to_date, api_key):
    """
    Fetches stock data using the Polygon API.

    Args:
        ticker (str): Stock ticker.
        from_date (str): Start date (YYYY-MM-DD format).
        to_date (str): End date (YYYY-MM-DD format).
        api_key (str): Polygon API key.

    Returns:
        pandas.DataFrame: Stock data (Open, High, Low, Close, Volume).
    """
    url = f"https://api.polygon.io/v2/aggs/ticker/{ticker}/range/1/day/{from_date}/{to_date}?adjusted=true&sort=asc&limit=5000&apiKey={api_key}"
    response = requests.get(url)
    response.raise_for_status()  # Handle exceptions if HTTP error occurs

    data = response.json()

    if data['results']:
        df = pd.DataFrame(data['results'])
        df['t'] = pd.to_datetime(df['t'], unit='ms')  # Convert timestamp to datetime
        df = df.rename(columns={'t': 'Date', 'o': 'Open', 'h': 'High', 'l': 'Low', 'c': 'Close', 'v': 'Volume'})
        df = df[['Date', 'Open', 'High', 'Low', 'Close', 'Volume']]
        return df
    else:
        return pd.DataFrame()  # Return empty DataFrame

Step 5: Define Momentum Indicator Calculation Function

Define functions to calculate momentum indicators (e.g., Simple Moving Average, Relative Strength Index (RSI)) from stock data:

def calculate_sma(data, window):
    """
    Calculates the Simple Moving Average (SMA).

    Args:
        data (pandas.Series): Stock price data.
        window (int): Moving average period.

    Returns:
        pandas.Series: SMA values.
    """
    return data.rolling(window=window).mean()

def calculate_rsi(data, window=14):
    """
    Calculates the Relative Strength Index (RSI).

    Args:
        data (pandas.Series): Stock price data.
        window (int): RSI period.

    Returns:
        pandas.Series: RSI values.
    """
    delta = data.diff()
    up, down = delta.copy(), delta.copy()
    up[up < 0] = 0
    down[down > 0] = 0

    roll_up1 = up.ewm(span=window, adjust=False).mean()
    roll_down1 = down.abs().ewm(span=window, adjust=False).mean()

    RS = roll_up1 / roll_down1
    RSI = 100.0 - (100.0 / (1.0 + RS))
    return RSI

Step 6: Implement Screening Logic

Implement logic to screen stocks based on momentum indicators. For example, you can filter stocks that are above a certain moving average or have an RSI above a specific value:

def screen_stocks(tickers, api_key, from_date, to_date):
    """
    Performs momentum screening on a list of stock tickers.

    Args:
        tickers (list): List of stock tickers.
        api_key (str): Polygon API key.
        from_date (str): Start date (YYYY-MM-DD format).
        to_date (str): End date (YYYY-MM-DD format).

    Returns:
        pandas.DataFrame: Screened stock data.
    """
    screened_stocks = []
    for ticker in tickers:
        try:
            data = get_stock_data(ticker, from_date, to_date, api_key)
            if not data.empty:
                data['SMA_20'] = calculate_sma(data['Close'], 20)
                data['RSI'] = calculate_rsi(data['Close'])

                # Example screening condition: Above 20-day moving average, RSI > 70
                last_row = data.iloc[-1]
                if last_row['Close'] > last_row['SMA_20'] and last_row['RSI'] > 70:
                    screened_stocks.append({
                        'Ticker': ticker,
                        'Close': last_row['Close'],
                        'SMA_20': last_row['SMA_20'],
                        'RSI': last_row['RSI']
                    })
        except Exception as e:
            print(f"Error processing {ticker}: {e}")

    return pd.DataFrame(screened_stocks)

Step 7: Execute Screening and Check Results

Execute the screening logic and check the results:

if __name__ == "__main__":
    # List of stock tickers to screen
    tickers = ['AAPL', 'MSFT', 'GOOG', 'TSLA', 'AMZN']
    today = datetime.today().strftime('%Y-%m-%d')
    one_year_ago = (datetime.today() - timedelta(days=365)).strftime('%Y-%m-%d')

    # Execute screening
    screened_stocks = screen_stocks(tickers, POLYGON_API_KEY, one_year_ago, today)

    # Print results
    if not screened_stocks.empty:
        print("Screened Stocks:")
        print(screened_stocks)
    else:
        print("No stocks met the screening criteria.")

4. Real-world Use Case / Example

I use this system to screen for promising stocks every morning before the market opens. Previously, I had to manually check data across multiple websites, but now, with the automated system, I can save over 30 minutes. For example, in early 2023, this system captured Tesla's momentum surge, providing an early investment opportunity. This was an opportunity that manual analysis might have missed, but a data-driven system caught it.

5. Pros & Cons / Critical Analysis

Pros:
- Time-saving through automated data collection and analysis
- Objective data-driven investment decisions
- Fast market response based on real-time data
- Customized screening using various momentum indicators
Cons:
- Polygon API usage incurs costs (free plan has limitations)
- Screening time may vary depending on API response speed
- Inherent risk of momentum investment strategies (past performance does not guarantee future returns)
- System maintenance and updates required
- Backtesting is essential: The validity of the strategy must be verified through tests on historical data.

6. FAQ

Q: Is the Polygon API free plan sufficient?
A: For initial testing and small-scale investments, the free plan may be sufficient. However, there are limitations on real-time data access and API call frequency, so a paid plan should be considered for serious investing.
Q: Which momentum indicators are most effective?
A: Effective momentum indicators vary depending on market conditions, investment goals, and risk tolerance. It is best to develop your own strategy by combining various indicators such as Simple Moving Average, Relative Strength Index (RSI), and MACD. It is important to validate the strategy's performance on historical data through backtesting.
Q: Should I unconditionally buy screened stocks?
A: Screening is merely a reference for investment decisions. You should conduct additional analysis (e.g., financial analysis, corporate outlook) on screened stocks and make investment decisions carefully, aligning with your investment goals and risk tolerance.
Q: Does using real-time data always lead to better results?
A: Real-time data can help respond to rapid market changes, but it does not always guarantee better results. Over-reliance on real-time data can lead to frequent trading, increasing transaction costs and emotional investment decisions. Careful analysis and a strategic approach are necessary.

7. Conclusion

The automated stock momentum screening system using Polygon API and Python is a powerful tool for automating data-driven investment decisions and increasing investment efficiency. Follow the steps presented in this guide to build your own screening system, refine your investment strategy, and achieve successful investments. Start analyzing stock data with Polygon API right now!

Building an Automated Stock Momentum Screening System using Polygon API and Python: Real-time Data-Driven Investment Strategy