Click to share! ⬇️

With the rise of self-directed investing, more and more individuals are taking control of their financial futures. But managing an investment portfolio isn’t just about buying and selling stocks; it also requires careful monitoring and analysis. Today, we’re going to show you how to build your own stock monitoring tool using Python and yfinance. Yfinance is a powerful library that allows you to connect to Yahoo Finance and extract a wealth of information about stocks. We’ll focus on stocks from the NASDAQ 100, such as Amazon (AMZN), Apple (AAPL), and Microsoft (MSFT). By the end of this tutorial, you’ll be able to track the performance of these stocks, analyze their historical data, and make more informed investment decisions. So, whether you’re a seasoned investor or just starting out, this guide will provide you with a valuable tool to help you navigate the stock market.

Introduction to Python and yfinance

Python is a versatile and widely used programming language, valued for its simplicity, readability, and vast array of libraries. One of these libraries is yfinance, a powerful tool that enables us to interact with the Yahoo Finance platform.

Yahoo Finance is a treasure trove of financial data, providing stock prices, dividends, splits, and other pertinent financial information. However, accessing this data manually can be a tedious process, especially if you are tracking multiple stocks. This is where yfinance comes in handy. With yfinance, we can programmatically retrieve this data, which paves the way for automation and complex analysis.

To use yfinance, you don’t need to be a Python expert. Even if you’re just starting your Python journey, you can still harness the power of yfinance. This library provides a user-friendly interface, allowing you to retrieve stock data with just a few lines of code. For example, if you want to get the historical price data for Amazon (AMZN), you can do it like this:

import yfinance as yf

data ='AMZN', start='2020-01-01', end='2022-12-31')

Setting Up Your Python Environment

Before we dive into coding, we need to ensure that our Python environment is set up correctly. Here’s a step-by-step guide:

Install Python: If you haven’t installed Python on your computer yet, visit the official Python website ( to download and install the latest version. During the installation process, make sure to check the box that says “Add Python to PATH” to ensure that Python is accessible from your command line.

Set Up a Virtual Environment: Virtual environments in Python allow you to create isolated spaces for your projects, ensuring that dependencies required by different projects do not interfere with each other. Here’s how you can create a virtual environment:

python -m venv myenv

This command will create a new virtual environment named “myenv”.

Activate the Virtual Environment: Before you can use the virtual environment, you need to activate it. The command for activation varies depending on your operating system. On Windows:


On MacOS/Linux:

source myenv/bin/activate

Install Necessary Libraries: Now that our virtual environment is activated, we can install the necessary libraries, namely pandas and yfinance. pandas is a data analysis library that we will use to manipulate the stock data, while yfinance is the library that will allow us to fetch the data from Yahoo Finance.

pip install pandas yfinance

You now have a Python environment set up and ready for financial data analysis! In the next section, we will dive deeper into using the yfinance library.

Understanding the yfinance Library

The yfinance library is an excellent tool for retrieving financial data from Yahoo Finance. It is both simple to use and highly flexible, allowing you to extract a wide range of financial data. Let’s go over some of its key features and functionalities.

Downloading Data: The primary use of yfinance is to download historical market data. You can download data for any ticker symbol, over any date range, and with a frequency of 1 minute, 1 hour, 1 day, 1 week, or 1 month. Here’s an example that downloads daily data for Apple (AAPL) from 2020 to 2022:

import yfinance as yf

data ='AAPL', start='2020-01-01', end='2022-12-31')

Ticker Module: The Ticker module in yfinance provides several methods to access different types of data for a specific stock. This includes information like financials, dividends, splits, sustainability, and more. Here’s an example that fetches the dividend history for Microsoft (MSFT):

msft = yf.Ticker("MSFT")
dividends = msft.dividends

Batch Download: If you’re interested in multiple stocks, yfinance allows you to download data for multiple tickers at once. This is a great way to analyze and compare different stocks. For example, you can download data for Amazon (AMZN), Alphabet (GOOGL), and Facebook (FB) like this:

data =['AMZN', 'GOOGL', 'FB'], start='2020-01-01', end='2022-12-31')

This is just a brief overview of what yfinance has to offer. As we continue our journey, you’ll get to see more of its capabilities in action, as we build our own stock monitoring tool.

Retrieving Stock Data from Yahoo Finance

Now that we have a grasp on Python, our environment is set up, and we understand the yfinance library, let’s start retrieving some stock data from Yahoo Finance. This process is straightforward with yfinance.

To begin with, we import the necessary libraries:

import yfinance as yf
import pandas as pd

Next, we decide on the stocks we want to monitor. For this tutorial, we’ll focus on three tech giants from the NASDAQ 100 index: Apple (AAPL), Amazon (AMZN), and Microsoft (MSFT).

Now, we can use yfinance’s download() function to retrieve the data:

tickers = ['AAPL', 'AMZN', 'MSFT']
start_date = '2020-01-01'
end_date = '2022-12-31'

data =, start=start_date, end=end_date)

This code will download the daily price history (including open, high, low, close, and adjusted close prices, and the volume of trades) for each of the specified stocks over the given date range.

The download() function returns a pandas DataFrame, a type of data structure that’s perfect for handling this kind of tabular data. You can view the first few rows of this DataFrame using the head() function:


Exploring and Analyzing Stock Data

Now that we have retrieved our stock data, it’s time to explore and analyze it. The pandas library provides a number of powerful tools for this purpose.

First, let’s have a look at the structure of our data:


The head() function displays the first few rows of our DataFrame, giving us a snapshot of our data. Each row corresponds to a date, and each column corresponds to a type of price (Open, High, Low, Close, Adj Close) for a particular stock.

To get a statistical summary of our data, we can use the describe() function:


This provides a summary of the central tendency, dispersion, and shape of the distribution for each column, including the count, mean, standard deviation, minimum, 25th percentile, median, 75th percentile, and maximum.

Next, we might want to examine the closing prices of our stocks over time. We can plot these using pandas’ built-in plotting capabilities:

data['Close'].plot(figsize=(10, 5))

This will create a line graph showing the closing prices of Apple, Amazon, and Microsoft over our specified date range. From this plot, we can get a visual sense of how these stocks have performed over time.

To examine the correlation between our stocks, we can use the corr() function:


This gives us a correlation matrix, showing how closely the closing prices of our stocks are related to each other.

These are just a few examples of the kind of analysis you can perform with pandas and yfinance. In the following sections, we will delve into how we can use this data to build our own stock monitoring tool.

Building Your Stock Monitoring Tool: Basic Features

Armed with our stock data and some initial analysis, we’re ready to start building the basic features of our stock monitoring tool. The goal is to create a program that automatically retrieves and analyzes stock data, giving you up-to-date insights on your chosen stocks. Let’s start with some basic features:

1. Daily Update:

Our tool should automatically fetch the latest stock data every day. We can accomplish this by scheduling our Python script to run at a specific time each day. Here’s a simple function that retrieves the latest data:

def fetch_latest_data(tickers):
    data =, period="1d")
    return data

2. Price Alerts:

Next, we’ll add a feature that sends an alert whenever a stock reaches a certain price. You could set this up to notify you when a stock’s price falls below a certain level (a good time to buy) or rises above a certain level (a good time to sell). Here’s a function that checks if a stock’s price is above or below a certain threshold:

def check_price(data, ticker, min_price=None, max_price=None):
    latest_close = data['Close'][ticker].iloc[-1]
    if min_price and latest_close < min_price:
        print(f"Alert: {ticker}'s price fell below {min_price}")
    if max_price and latest_close > max_price:
        print(f"Alert: {ticker}'s price rose above {max_price}")

3. Performance Summary:

Finally, let’s add a feature that provides a summary of each stock’s performance. This could include the current price, the day’s change in price, and the change in price over the past week, month, or year:

def print_summary(data, ticker):
    current_price = data['Close'][ticker].iloc[-1]
    day_change = data['Close'][ticker].pct_change().iloc[-1]
    week_change = data['Close'][ticker].pct_change(periods=7).iloc[-1]
    month_change = data['Close'][ticker].pct_change(periods=30).iloc[-1]
    year_change = data['Close'][ticker].pct_change(periods=365).iloc[-1]

    print(f"{ticker} Summary:")
    print(f"Current Price: {current_price}")
    print(f"Day Change: {day_change * 100}%")
    print(f"Week Change: {week_change * 100}%")
    print(f"Month Change: {month_change * 100}%")
    print(f"Year Change: {year_change * 100}%")

These are the basic features of our stock monitoring tool. In the next section, we’ll discuss how to add some advanced features to make our tool even more powerful.

Adding Advanced Features to Your Stock Monitoring Tool

With the basic features in place, let’s extend our stock monitoring tool with some advanced functionalities to deepen our financial analysis and make our tool more versatile.

1. Moving Averages:

A moving average is a commonly used indicator in technical analysis that helps smooth out price action by filtering out the “noise” from random price fluctuations. We can add a feature to calculate the simple moving average (SMA) over a given period:

def calculate_sma(data, ticker, window):
    sma = data['Close'][ticker].rolling(window=window).mean()
    return sma

2. Relative Strength Index (RSI):

The Relative Strength Index (RSI) is a momentum oscillator that measures the speed and change of price movements. It’s used to identify overbought or oversold conditions in a market:

def calculate_rsi(data, ticker, periods=14):
    delta = data['Close'][ticker].diff()
    up, down = delta.copy(), delta.copy()
    up[up < 0] = 0
    down[down > 0] = 0
    avg_gain = up.rolling(window=periods).mean()
    avg_loss = abs(down.rolling(window=periods).mean())
    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))
    return rsi

3. Email Notifications:

Rather than simply printing alerts to the console, we can enhance our tool by sending email notifications. This way, you can stay informed about your stocks even when you’re away from your computer:

import smtplib

def send_email(subject, body, to):
    from_email = ""
    password = "your-email-password"
    server = smtplib.SMTP('', 587)
    server.login(from_email, password)
    msg = f"Subject: {subject}\n\n{body}"
    server.sendmail(from_email, to, msg)

4. Interactive Dashboard:

For a more visual and interactive experience, consider integrating your tool with a dashboarding library like Dash or Streamlit. This would allow you to create beautiful, interactive dashboards that can be accessed through a web browser.

Case Study: Monitoring NASDAQ 100 Stocks

Let’s now put our stock monitoring tool into action. For this case study, we’ll focus on monitoring stocks from the NASDAQ 100 index.

First, we’ll need to fetch the current list of NASDAQ 100 stocks. We can do this by using the Index module in finance:

nasdaq100 = yf.Ticker("^NDX")
tickers = nasdaq100.components['Symbol'].tolist()

Next, we’ll fetch the latest stock data for these tickers:

data = fetch_latest_data(tickers)

Let’s say we’re particularly interested in Apple (AAPL), Amazon (AMZN), and Microsoft (MSFT). We can set price alerts for these stocks. For example, we might want to be alerted if AAPL falls below $150, or if AMZN or MSFT rise above $3500 and $300, respectively:

check_price(data, 'AAPL', min_price=150)
check_price(data, 'AMZN', max_price=3500)
check_price(data, 'MSFT', max_price=300)

We can also print a performance summary for these stocks:

print_summary(data, 'AAPL')
print_summary(data, 'AMZN')
print_summary(data, 'MSFT')

To gain some insights on the overall market condition, we might want to calculate and plot the 50-day and 200-day moving averages for the NASDAQ 100 index:

sma50 = calculate_sma(data, '^NDX', 50)
sma200 = calculate_sma(data, '^NDX', 200)

Finally, we could calculate the RSI for each of our chosen stocks to identify potential buying or selling opportunities:

rsi_aapl = calculate_rsi(data, 'AAPL')
rsi_amzn = calculate_rsi(data, 'AMZN')
rsi_msft = calculate_rsi(data, 'MSFT')

In summary, this case study illustrates how we can use our stock monitoring tool to track and analyze NASDAQ 100 stocks. Of course, this is just an example – the true power of our tool lies in its flexibility to adapt to your own investing strategy and financial goals.

Useful Extensions and Add-Ons for Your Stock Monitoring Tool

As you continue to use and refine your stock monitoring tool, you may find it useful to integrate additional libraries and services to further enhance its capabilities. Here are a few suggestions:

1. Advanced Visualization Libraries:

While pandas provides basic plotting capabilities, you might want to use a more advanced visualization library for more complex plots. Matplotlib and seaborn are excellent choices for static plots, while Plotly and Bokeh offer interactive visualizations.

2. Machine Learning Libraries:

Consider incorporating machine learning libraries like scikit-learn or TensorFlow to add predictive capabilities to your tool. For example, you could train a model to predict future stock prices or to identify investment opportunities based on historical data.

3. Real-Time Data Feeds:

While yfinance is great for retrieving historical data, it might not be sufficient if you need real-time data. In this case, you could consider integrating a real-time data feed from a service like Alpha Vantage or IEX Cloud.

4. Backtesting Libraries:

If you’re using your tool to develop trading strategies, a backtesting library like Backtrader or PyAlgoTrade could be invaluable. These libraries allow you to test your strategies on historical data to see how they would have performed.

5. Cloud Deployment:

Finally, consider deploying your tool to the cloud (using a service like AWS, Google Cloud, or Heroku) to ensure it runs reliably and continuously, regardless of the state of your local machine. You could also use cloud services to store your data and send notifications.

These are just a few ideas for how you can extend your stock monitoring tool. The best extensions and add-ons will depend on your specific needs and interests. As always, the most important thing is to keep experimenting, learning, and refining your tool to better serve your investment goals.

Conclusion: Empowering Your Investment Strategy with Python and yfinance

We’ve now walked through the process of building a robust stock monitoring tool using Python and yfinance. This tool is not only a practical asset for your investment strategy, but also a great example of how programming can be a powerful tool in the world of finance.

This journey has covered a wide range of features, from basic data retrieval and analysis, to advanced functionalities like moving averages, relative strength index calculations, email notifications, and interactive dashboards. We’ve explored how the tool can be used to monitor stocks from the NASDAQ 100 index, and discussed potential extensions and add-ons to enhance its capabilities.

Remember, while our examples focused on a few specific stocks, the methods we used can be applied to any stock available on Yahoo Finance. The tool is flexible and can be customized to suit your personal investment goals and strategies.

In conclusion, with Python and yfinance, you’re not just limited to passively observing market trends. You can actively engage with financial data, conduct your own analysis, and make more informed decisions about your investments. Whether you’re a seasoned investor or a beginner, this tool is a step towards a more data-driven and empowered investment approach.

Click to share! ⬇️