On April 10th, I was invited to the event “Treasury in the Digital Money Era” hosted by the Paris Blockchain Society in collaboration with top-tier firms like Accenture, Onyx by J.P. Morgan, Citi Treasury and Trade Solutions, Fortris, and Societe Generale-FORGE.

As a professional working in the evolving crypto industry who had previous experience in cash management at BNP PARIBAS, I was looking forward to hearing what institutions had to say about BUIDL — BlackRock USD Institutional Digital Liquidity Fund. I was not disappointed.

Exploring Digital Treasury Innovations with Accenture, Onyx by J.P. Morgan, Citi, Fortris, and Societe Generale — FORGE

This event brought together CAC40 CFOs, Treasurers, and Payments C-Suite Executives, as well as professionals from the crypto industry. Discussions focused on the integration of digital assets in treasury operations, cash management, and cross-border payments, providing rich insights into the current state and future possibilities of digital finance.

The speakers were:

• Basak Toprak, Executive Director, EMEA Head of Coin Systems at Onyx by J.P. Morgan
• David Cunningham, Global Head of Strategy and Partnerships for Digital Assets at Citi’s Treasury and Trade Solutions
• Noah Herman, CRO at Fortris
• Guillaume Chatain, Head of Sales at Societe Generale-Forge
• John Cronin, CEO Europe at Zodia Custody
• Alexandre Laizet, Digital Assets Lead at Accenture (Moderator)

Amid the variety of topics discussed — from the potential of an ETH ETF to the strategic marketing behind memecoins — the subject that captured the audience’s attention was BlackRock’s BUIDL, the newly launched tokenized money market fund.

As a quick reminder, here is the definition of a money market fund from Investopedia:

“A money market fund is a type of mutual fund that invests in high-quality, short-term debt instruments, cash, and cash equivalents.

Though not quite as safe as cash, money market funds are considered extremely low-risk on the investment spectrum.

A money market fund generates income (taxable or tax-free, depending on its portfolio), but little capital appreciation.

Money market funds should be used as a place to park money temporarily before investing elsewhere or making an anticipated cash outlay; they are not suitable as long-term investments.”

Now that we all have the definition in mind, let’s take a deep dive into BlackRock’s BUIDL’s main characteristics and reflect on how it reshapes traditional money market funds:

• Fund Manager: BlackRock
• Fund Custodian: BNY Mellon
• Fund Administrator: BNY Mellon
• Transfer Agent: Securitize, LLC. The leader in tokenizing real-world assets
• Settlement Asset: USDC, a dollar-pegged stablecoin by Circle
• Blockchain Deployment: Launched on the Ethereum blockchain, BUIDL offers a stable value of $1 per token. It targets institutional investors
• Professional Fund: BUIDL operates as a professional fund. It consists of various low-risk investments such as short-term U.S. Treasury bills and repurchase agreements (with assets' maturity within three months) for high liquidity and low duration risk
• Access: The fund is only accessible to whitelisted investors after completing a KYC and AML process
• On-chain Liquidity: USDC liquidity facility managed via smart contracts, allowing 24/7 exchange of BUIDL tokens for USDC. Investors can exchange their BUIDL tokens for USDC at any time, 24/7 through a USDC - BUIDL pool accessible via the interface of Securitize Markets and/or through direct interaction with the smart contract
• Dividends Distribution: Dividends accrue daily at 3:00 PM (New York time) for the registered shareholder of the fund and are distributed in kind (the fund's token) on the first business day of the following month. Each shareholder's dividend corresponds to their proportional share of the net income from that day's investments, minus fees related to the commission—like what exists already in a decentralized finance (DeFi) pool system
• DeFi: BUIDL is an ERC-20 token. It would be conceivable to imagine a "wBUIDL" (Wrapped BUIDL) to integrate into decentralized finance (DeFi) protocols
• Tokenized Funds: There are already tokenized funds deployed on public blockchains: Franklin Templeton Benji (300 million - Polygon, Stellar), Ondo Finance OUSG (104 million - Ethereum, Polygon, Solana), Matrixdock STBT (80 million - Ethereum)

The bottom line is.

Blockchain technology is driving disruptive financial innovations. Tokenized money market funds, smart contracts, and stablecoins are reshaping traditional finance and the way companies, banks, and institutions conduct business and interact with each other.

“I think what was most important for the audience to take away is that stablecoins are not going away. They are the killer app of crypto and they will have an impact not just on banks but on global business processes. It will create new industries and it will eradicate some existing industries.” — John Cronin, CEO Europe of Zodia Custody

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow and clap for crypto and blockchain contents.

Resources:

1. BlackRock Launches Its First Tokenized Fund, BUIDL, on the Ethereum Network. Business Wire, March 20, 2024. Available at https://www.businesswire.com/news/home/20240320771318/en/BlackRock-Launches-Its-First-Tokenized-Fund-BUIDL-on-the-Ethereum-Network.
2. New BlackRock Tokenized Fund Garners $160 Million in Deposits. The Block, March 22, 2024. Available at https://www.theblock.co/post/285142/new-blackrock-tokenized-fund-garners-160-million-in-deposits.
3. Conference Highlights: Exploring Treasury in the Digital Money Era. Paris Blockchain Society, LinkedIn Post, April 10, 2024. Available at https://www.linkedin.com/posts/paris-blockchain-society_conference-highlights-exploring-treasury-activity-7189680198005465088-D40Z.

Disclaimer

The information contained in this article is provided for general informational purposes only and is not intended to be, and should not be relied upon as, legal, financial, or professional advice. This article is based on the information available at the time of its preparation and is subject to change without notice. The Author assumes no liability or responsibility for any errors or omissions in the content of this assessment or for any actions taken based on the information provided herein. You should seek professional advice from a qualified attorney or financial advisor before making any decisions or taking any actions based on the information contained in this article. The Author disclaims all liability and responsibility for any actions taken or not taken in reliance on the information contained in this article.

My Takeaways from Paris Blockchain Week 2024 and the Institutional Buzz Around BUIDL was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Access market data with these 3 free APIs using only a few lines of code.

Gain instant access to OHLCV (Open, High, Low, Close, Volume) data and more for stocks, digital assets, and forex.

• You can use the ccxt library to fetch data from Kraken.
• You can use direct HTTP requests to get data from Binance.
• You can use the yfinance library to get data from Yahoo Finance.

We will fetch the market data without defining functions for simplification purposes. That way, beginner programmers can still access market data while understanding what’s happening in the code.

1. Fetching Data from Kraken using ccxt

By running the following script, you will obtain 720 days of OHLCV market data.

import ccxt
import pandas as pd

# Here we initialize the Kraken "connection"
kraken = ccxt.kraken()

# Setting the trading pair and the timeframe
symbol = 'BTC/USD'
timeframe = '1d'

# Fetch OHLCV data
ohlcv = kraken.fetch_ohlcv(symbol, timeframe)

# Then we convert the fetched data into a DataFrame and process timestamps
data_kraken = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
data_kraken['timestamp'] = pd.to_datetime(data_kraken['timestamp'], unit='ms')
data_kraken.set_index('timestamp', inplace=True)

data_kraken.tail()

2. Fetching Data from Binance using HTTP Requests

By running the following script, you will obtain 365 days of market data. Note that you can fetch more than just the OHLCV data.

import requests

# Below we fefine the symbol, interval, and time range
symbol_binance = 'BTCUSDT'
interval = '1d'
start_time = '1640995200000'  # Example timestamp for 01-01-2022
end_time = '1672531199000'    # Example timestamp for 01-01-2023

# Set the URL and fetching raw data
url = f"https://api.binance.com/api/v3/klines?symbol={symbol_binance}&interval={interval}&startTime={start_time}&endTime={end_time}"
response = requests.get(url)
data_binance_raw = response.json()

# Then we convert the raw data into a DataFrame and process timestamps
columns_binance = ['Open time', 'Open', 'High', 'Low', 'Close', 'Volume', 'Close time', 'Quote asset volume', 'Number of trades', 'Taker buy base asset volume', 'Taker buy quote asset volume', 'Ignore'] # Choose what you need
data_binance = pd.DataFrame(data_binance_raw, columns=columns_binance)
data_binance['Open time'] = pd.to_datetime(data_binance['Open time'], unit='ms')
data_binance['Close time'] = pd.to_datetime(data_binance['Close time'], unit='ms')

data_binance.tail()

Here, the variables fetched from Binance are:

• Open time: The opening time of the time interval (in datetime format).
• Open: The opening price of the asset for the given interval (as a string, convert to float for numerical operations).
• High: The highest price of the asset during the interval (as a string, convert to float for numerical operations).
• Low: The lowest price of the asset during the interval (as a string, convert to float for numerical operations).
• Close: The closing price of the asset for the given interval (as a string, convert to float for numerical operations).
• Volume: The trading volume of the asset during the interval (as a string, convert to float for numerical operations).
• Close time: The closing time of the time interval (in datetime format).
• Quote asset volume: The trading volume measured in the quote currency (as a string, convert to float for numerical operations).
• Number of trades: The number of trades that occurred during the interval (as an integer).
• Taker buy base asset volume: The volume of taker buy orders measured in the base asset (as a string, convert to float for numerical operations).
• Taker buy quote asset volume: The volume of taker buy orders measured in the quote asset (as a string, convert to float for numerical operations).
• Ignore: A placeholder for future use (as a string, generally ignored in analysis).

You can also choose to only fetch the OHLCV data and leave the other variables.

How to convert to float for numerical operations

data_binance['Open'] = data_binance['Open'].astype(float)

3. Fetching Data from Yahoo Finance using yfinance

You can use Yahoo Finance to retrieve stock data.

import yfinance as yf

# Define the symbol and fetch data from Yahoo Finance
symbol_yahoo = 'TSLA'
data_yahoo = yf.download(symbol_yahoo, start="2022-01-01", end="2023-01-01")

data_yahoo

Conclusion

You can now access market data from Kraken, Binance, and Yahoo Finance with just a few lines of code.

Don’t forget API rate limits and always verify the data before using it in a trading strategy!

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow and clap for more full Python scripts.

Follow us on Substack

Disclaimer: While this article uses real market data for demonstration purposes, it is imperative to note that the content is provided for informational and educational purposes only. This article (python script included) is not under any circumstances financial advice. This article and code aim to enhance financial knowledge and Python programming skills. Always seek advice from a qualified financial professional before making any investment decisions. Investing involves risks, including the potential loss of principal.

Extracting valuable financial insights to inform better investment decisions is the goal of every investor and stakeholder. More than analyzing data quickly, it’s also about reproducing that analysis over and over again with different assets. Having the same analytical starting point is crucial. And Python is the perfect tool for this kind of analysis.

In this article, we will go through a complete financial analytic Python script step by step. This script is designed to fetch, preprocess, analyze, and visualize stock data. We will understand how automated analyses can offer valuable and systematic insights to investors and stakeholders.

Our analysis will focus on the AI/tech industry from January 1, 2020, to January 1, 2023. The stocks analyzed include ‘GOOGL’ (Google), ‘NVDA’ (NVIDIA), ‘AMD’ (AMD), ‘INTC’ (Intel), ‘TSLA’ (Tesla), ‘IBM’ (IBM), ‘MSFT’ (Microsoft), and ‘ZM’ (Zoom). Each company presents a unique narrative within the AI/tech industry.

Of course, you can add more stocks to the analysis, look at stocks from another industry, compare two stocks, change the period… The possibilities are endless. The purpose of this Python script is that it can be reproduced. You can replicate the analysis with any stocks!

Outline

The Python script that we will create is divided into the following sections:

1. Data Retrieval and Preprocessing Function
2. Data Visualization Function
3. Daily Returns Distribution Visualization Function
4. Risk and Return Analysis Visualization Function
5. Correlation Analysis Visualization Function

This is the final result.

Disclaimer: While this article uses real market data for demonstration purposes, it is imperative to note that the content is provided for informational and educational purposes only. This article (python script included) is not under any circumstances financial advice. This article and code aim to enhance financial knowledge and Python programming skills. Always seek advice from a qualified financial professional before making any investment decisions. Investing involves risks, including the potential loss of principal.

Part 1: Data Retrieval and Preprocessing Function

We first create the fetch_and_preprocess function. The data is from Yahoo Finance and you can add or remove stocks from the stocks list (see in the python script below). The fetch_and_preprocess function returns a dataframe with all the stock data. We thus get the OHLCV data and adjusted close price for all desired stocks.

“Adjusted close is the closing price after adjustments for all applicable splits and dividend distributions.” — Yahoo Finance.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import yfinance as yf
from scipy.stats import skew, kurtosis


def fetch_and_preprocess(ticker, start_date, end_date):
    """
    This function fetches stock data from Yahoo Finance and preprocess the stocks.
    
    Parameters:
    - ticker (str): The stock symbol.
    - start_date (str): The start date for fetching the data.
    - end_date (str): The end date for fetching the data.
    """
    data = yf.download(ticker, start=start_date, end=end_date)
    data.reset_index(inplace=True)
    data['Date'] = pd.to_datetime(data['Date'])
    data['Daily Return'] = data["Adj Close"].pct_change()
    return data

In this fetch_and_preprocess function, we reset the index, ensure our Date variable is in the correct datetime format, and calculate the Daily Return variable using the adjusted close variable fetched from Yahoo Finance.

Daily returns give us insights into the stock’s volatility and overall price movement. It can provide information about the stability and risk associated with a particular stock.

The fetch_and_preprocess function has the following parameters:

• ticker (str): The stock symbol.
• start_date (str): The start date for fetching the data.
• end_date (str): The end date for fetching the data.

In the script, we will call this function as follows:
list_of_dataframes = [fetch_and_preprocess(stock, ‘2018–01–01’, ‘2023–01–01’) for stock in stocks]

Where stock is the list of stocks with the tickers:
stocks = [‘GOOGL’, ‘NVDA’, ‘AMD’, ‘INTC’, ‘TSLA’, ‘IBM’, ‘MSFT’, ‘ZM’]

Part 2: Data Visualization Functions

The plot_attributes function plots the following attributes: Adjusted Close, Daily Return, and Volume. This means it will plot these variables for all stocks. That is the first 3 graphs on our analysis.

def plot_attributes(list_of_dataframes, titles):
    """
    This function plots the following attributes: Adjusted Close, Daily Return, and Volume.
    
    Parameters:
    - list_of_dataframes (list): List of dataframes containing stock data.
    - titles (list): List of titles for the stocks.
    """
    attributes = ["Adj Close", "Daily Return", "Volume"]
    plt.figure(figsize=(25, 20))
    for idx, attribute in enumerate(attributes, 1):
        plt.subplot(3, 1, idx)
        for df, title in zip(list_of_dataframes, titles):
            plt.plot(df["Date"], df[attribute], label=title)
        plt.title(attribute + " Over Time")
        plt.xlabel("Date")
        plt.ylabel(attribute)
        plt.legend()
    plt.tight_layout()

The function’s parameters are:

• list_of_dataframes (list): List of dataframes containing stock data.
• titles (list): List of titles/labels for the stocks.

Where titles is the list of the stocks titles:
titles = [“Google”, “NVIDIA”, “AMD”, “Intel”, “Tesla”, “IBM”, “Microsoft”, “Zoom”]

Let’s take a moment to review the intricacies of the code.

Explaining enumerate

enumerate iterates over an iterable (like a list in our code) and access the index of the current item being processed.

The general syntax is the following:

for index, element in enumerate(iterable, start_index):

• index: current index in the iteration, which starts from start_index.
• element: current element in the iteration.
• iterable: object to iterate over.
• start_index: starting index, default is 0.

This is what we have in our code:

for idx, attribute in enumerate(attributes, 1):

• idx: The index, starting from 1 (for reading purposes we start with 1).
• attribute: The element, which will be each string in attributes on each iteration.
• attributes: our list of strings [“Adj Close”, “Daily Return”, “Volume”] that will be iterated.

Explaining zip

zip iterates over two or more iterables in parallel. With two iterables, zip groups the first elements of each iterable, then the second elements.

The general syntax is the following:

for element1, element2 in zip(iterable1, iterable2):

• element1: current element from iterable1.
• element2: current element from iterable2.

This is what we have in our code:

for df, title in zip(list_of_dataframes, titles):

• df: a “dataframe” from the list_of_dataframes list.
• title: its corresponding title from the titles list.

Breakdown of plot_attributes Function:

1. Attributes List: These are the variables we want to plot.

attributes = ["Adj Close", "Daily Return", "Volume"]

2. Figure Size: We initialize a new figure with a specified size (width 25, height 20) to plot.

plt.figure(figsize=(25, 20))

3. First Loop: We iterate over each attribute with the index starting from 1.

for idx, attribute in enumerate(attributes, 1):

4. Subplot: We create a subplot grid of 3 rows and 1 column.

plt.subplot(3, 1, idx)

5. Second Loop: We iterate concurrently over list_of_dataframes and titles.

for df, title in zip(list_of_dataframes, titles):

6. Plotting Line: We plot the attribute.

plt.plot(df["Date"], df[attribute], label=title)

7. Title, Labels, and Legend: We define the title, the x and y-axis labels, and finally add a legend

plt.title(attribute + " Over Time")
plt.xlabel("Date")
plt.ylabel(attribute)
plt.legend()

8. Layout Adjustment: We make sure that the subplots fit

plt.tight_layout()

When we call the plot_attributes function we generate a 3-row subplot. We get each attribute for all stocks “Adj Close”, “Daily Return”, and “Volume” over the time period that we defined.

Part 3: Daily Returns Distribution Visualization Function

The plot_daily_return_distribution function plots the distribution of daily returns for all stocks while also calculating the average expected return, the asymmetry of the returns distribution (skewness), and the “tailedness” of the returns distribution (kurtosis).

def plot_daily_return_distribution(list_of_dataframes, titles):
    """
    This function plots the distribution of daily returns along with the mean, skewness, and kurtosis.
    
    Parameters:
    - list_of_dataframes (list): List of dataframes containing stock data.
    - titles (list): List of titles for the stocks.
    """
    plt.figure(figsize=(20, 15))
    for idx, df in enumerate(list_of_dataframes):
        plt.subplot(4, 2, idx + 1)
        sns.histplot(df["Daily Return"].dropna(), color="blue", kde=True, bins=50)
        
        # We calculate the mean, skewness, and kurtosis
        mean_return = df["Daily Return"].mean()
        skewness_return = skew(df["Daily Return"].dropna())
        kurtosis_return = kurtosis(df["Daily Return"].dropna())
        
        # Then we add a vertical line for the mean
        plt.axvline(mean_return, color='r', linestyle='--', label=f'Mean: {mean_return:.6f}')
        
        # And we add text for the calculated statistics
        stats_text = f"Skewness: {skewness_return:.2f}\nKurtosis: {kurtosis_return:.2f}"
        plt.annotate(stats_text, xy=(0.05, 0.95), xycoords='axes fraction', fontsize=9, ha='left', va='top')
        
        plt.title(titles[idx] + ": Distribution of Daily Returns")
        plt.xlabel("Daily Return")
        plt.ylabel("Frequency")
        plt.legend()
    plt.tight_layout()

The function’s parameters are:

• list_of_dataframes (list): List of dataframes containing stock data.
• titles (list): List of titles for the stocks.

Financially, it’s interesting to visualize the distribution of daily returns for our set of stocks.

First of all, the histograms allow us to make a quick assessment of the risk and volatility of the given stocks by looking at their spreads and tendencies. Wider spreads indicate higher volatility, which is generally riskier.

Second, by visualizing the histograms’ distributions, we can quickly perform a normality check. Certain financial models, like the Black-Scholes model, assume that returns are normally distributed.

Third, we can calculate the mean of the distribution for each stock, which would give us the expected returns. Also, it’s important to look at the proportion of negative returns and get a sense of the risk of losses. The mean (i.e., the expected return) is a critical parameter for many financial models as it indicates the average expected return. A daily mean close to zero is common due to upward and downward movements.

We also calculate skewness, which measures the asymmetry of the returns distribution. Positive skew indicates that the distribution tail is skewed towards the right, while negative skew indicates a left tail. What does this mean financially? It provides insight into the asymmetry of returns. Investors might prefer positive skewness, indicating a higher probability of large positive returns. Skewness also indicates the likelihood of extreme returns on one side of the mean.

We also calculate kurtosis, measuring the “tailedness” of the distribution. High kurtosis indicates heavy tails and sharp peaks (more prone to outliers), while low kurtosis indicates light tails and a flatter peak. Financially, high kurtosis suggests a higher likelihood of extreme returns (either high or low). Understanding kurtosis helps in risk management, particularly in evaluating the risk of extreme movements.

Fourth, examining the histograms of our various stocks allows us to compare their risk-return profiles and make better-informed investment decisions. If some stocks have similar (or dissimilar) return distributions, identifying them could help us in our portfolio management decision: how do we diversify our portfolio and/or how do we optimize our asset allocation?

Finally, visualizing histograms allows us to identify outliers. Spotting the extreme values helps us understand the likelihood of extreme returns or losses.

Part 4: Risk and Return Analysis Visualization Function

The plot_risk_vs_expected_returns function plots a scatter plot where each point represents a stock.

def plot_risk_vs_expected_returns(returns, titles):
    """
    This function plots risk vs expected returns.
    
    Parameters:
    - returns (pd.DataFrame): Dataframe containing stock returns.
    - titles (list): List of titles for the stocks.
    """
    plt.figure(figsize=(20, 10))
    plt.scatter(returns.std(), returns.mean(), s=100)
    plt.ylabel('Expected Return')
    plt.xlabel('Risk')
    for label, x, y in zip(titles, returns.std(), returns.mean()):
        plt.annotate(label, xy=(x, y), xytext=(10, 0), textcoords='offset points')
    plt.title("Risk vs Expected Returns")
    plt.tight_layout()

The function has the following parameters:

• returns (pd.DataFrame): it is a DataFrame containing all stock returns (see below).
• titles (list): a list of titles for our chosen stocks.

This scatter plot is an interesting visualization because it allows us to visualize the trade-off between risk and returns for our chosen stocks.

On the x-axis, we have the standard deviation of the stocks’ returns, representing risk. The standard deviation of returns is a proxy for a stock’s risk; the higher the standard deviation, the higher the risk due to increased price volatility.

On the y-axis, we have the mean of returns, representing the expected/average return.

The interpretation of this scatter plot goes as follows: On the x-axis, the further right, the higher risk/volatility. On the y-axis, the higher up, the higher expected return.

While a higher standard deviation indicates higher ‘risk’, it does not necessarily mean ‘bad’ as it depends on an investor’s risk tolerance.

What kind of investment insights can we derive from this scatter plot?

First of all, this plot illustrates that seeking higher returns usually means accepting higher risk. The risk-reward trade-off is well depicted on this scatter plot.

Also, we can use this plot for our portfolio diversification. Here, we can identify stocks that could enhance our portfolio diversification by analyzing their return and risk in relation to existing investments. For instance, if you already own Google and Tesla stocks, it could be interesting to visualize the next ones you want to purchase on this particular plot to enhance diversification.

Finally, this plot aids us in our stock selection. It enables us to see which ones offer the highest returns with the lowest risk.

Note that investors should balance between risk and return based on their investment strategy and risk tolerance; some might prefer a low-risk, low-return strategy, while others might be comfortable with a high-risk, high-return approach.

Part 5. Correlation Analysis Visualization Function

The plot_correlations function creates a correlation heatmap and calculates the correlation matrix of the returns of our chosen stocks.

def plot_correlations(returns):
    """
    Plot correlations heatmap.
    
    Parameters:
    - returns (pd.DataFrame): Dataframe containing stock returns.
    """
    plt.figure(figsize=(12, 8))
    sns.heatmap(returns.corr(), annot=True, cmap="YlGnBu")
    plt.title("Correlation Matrix of Daily Returns")
    plt.tight_layout()

The function has the following parameter:

• returns (pd.DataFrame): it is a DataFrame containing all stock returns.

This correlation heatmap is interesting because it allows us to visualize the pairwise correlation between the returns of our chosen stocks.

Here, we calculate the correlation coefficients that have a range between -1 to 1. This is how we interpret them: a coefficient of -1 indicates a perfect negative correlation (one stock increases in value while the other decreases), 1 indicates a perfect positive correlation (stocks move in the same direction), and 0 indicates no correlation. Note that the darker the color, the stronger the correlation.

Correlation does not imply causation.

Financially, we can use this correlation heatmap for diversification. By identifying stocks that are less positively/negatively correlated, we can build a diversified portfolio. This strategic stock allocation can help us optimize returns while managing risk. Understanding correlations allows us to anticipate potential impacts on our portfolio when a particular stock (or sector, for example) increases or decreases in value. This visual summary of how the returns of different stocks move relative to each other is key for informed investment decisions. It goes without saying that other factors, like the companies’ financial health, macroeconomic indicators, and/or industry trends should be taken into account.

What Now?

Finance with Python is powerful. We’ve created a suite of visualization functions that highlight hidden patterns and intricate relationships between stocks from the tech industry.

What do we have exactly that could be reproduced for stock analysis:

• Time-series plots that chart stock prices and trading volumes, revealing trends and volatile periods that might be useful for investment decisions.
• Daily return distributions through histograms with the overlaying mean, skewness, and kurtosis. This statistical visualization illustrates the inherent risks and potential rewards of our chosen stocks.
• A risk-return scatter plot that serves as a guided investment decision tool by aligning stocks’ risk with return expectations.
• Lastly, the correlation heatmap allows us to detect how stocks might move relative to each other, thus helping us design diversified portfolios.

Please find below the full Python script

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import yfinance as yf
from scipy.stats import skew, kurtosis


def fetch_and_preprocess(ticker, start_date, end_date):
    """
    This function fetches stock data from Yahoo Finance and preprocess the stocks.
    
    Parameters:
    - ticker (str): The stock symbol.
    - start_date (str): The start date for fetching the data.
    - end_date (str): The end date for fetching the data.
    """
    data = yf.download(ticker, start=start_date, end=end_date)
    data.reset_index(inplace=True)
    data['Date'] = pd.to_datetime(data['Date'])
    data['Daily Return'] = data["Adj Close"].pct_change()
    return data

def plot_attributes(list_of_dataframes, titles):
    """
    This function plots the following attributes: Adjusted Close, Daily Return, and Volume.
    
    Parameters:
    - list_of_dataframes (list): List of dataframes containing stock data.
    - titles (list): List of titles for the stocks.
    """
    attributes = ["Adj Close", "Daily Return", "Volume"]
    plt.figure(figsize=(25, 20))
    for idx, attribute in enumerate(attributes, 1):
        plt.subplot(3, 1, idx)
        for df, title in zip(list_of_dataframes, titles):
            plt.plot(df["Date"], df[attribute], label=title)
        plt.title(attribute + " Over Time")
        plt.xlabel("Date")
        plt.ylabel(attribute)
        plt.legend()
    plt.tight_layout()

def plot_daily_return_distribution(list_of_dataframes, titles):
    """
    This function plots the distribution of daily returns along with the mean, skewness, and kurtosis.
    
    Parameters:
    - list_of_dataframes (list): List of dataframes containing stock data.
    - titles (list): List of titles for the stocks.
    """
    plt.figure(figsize=(20, 15))
    for idx, df in enumerate(list_of_dataframes):
        plt.subplot(4, 2, idx + 1)
        sns.histplot(df["Daily Return"].dropna(), color="blue", kde=True, bins=50)
        
        # We calculate the mean, skewness, and kurtosis
        mean_return = df["Daily Return"].mean()
        skewness_return = skew(df["Daily Return"].dropna())
        kurtosis_return = kurtosis(df["Daily Return"].dropna())
        
        # Then we add a vertical line for the mean
        plt.axvline(mean_return, color='r', linestyle='--', label=f'Mean: {mean_return:.6f}')
        
        # And we add text for the calculated statistics
        stats_text = f"Skewness: {skewness_return:.2f}\nKurtosis: {kurtosis_return:.2f}"
        plt.annotate(stats_text, xy=(0.05, 0.95), xycoords='axes fraction', fontsize=9, ha='left', va='top')
        
        plt.title(titles[idx] + ": Distribution of Daily Returns")
        plt.xlabel("Daily Return")
        plt.ylabel("Frequency")
        plt.legend()
    plt.tight_layout()


def plot_risk_vs_expected_returns(returns, titles):
    """
    This function plots risk vs expected returns.
    
    Parameters:
    - returns (pd.DataFrame): Dataframe containing stock returns.
    - titles (list): List of titles for the stocks.
    """
    plt.figure(figsize=(20, 10))
    plt.scatter(returns.std(), returns.mean(), s=100)
    plt.ylabel('Expected Return')
    plt.xlabel('Risk')
    for label, x, y in zip(titles, returns.std(), returns.mean()):
        plt.annotate(label, xy=(x, y), xytext=(10, 0), textcoords='offset points')
    plt.title("Risk vs Expected Returns")
    plt.tight_layout()

def plot_correlations(returns):
    """
    Plot correlations heatmap.
    
    Parameters:
    - returns (pd.DataFrame): Dataframe containing stock returns.
    """
    plt.figure(figsize=(12, 8))
    sns.heatmap(returns.corr(), annot=True, cmap="YlGnBu")
    plt.title("Correlation Matrix of Daily Returns")
    plt.tight_layout()

# List of AI/Tech industry stocks and their names
stocks = ['GOOGL', 'NVDA', 'AMD', 'INTC', 'TSLA', 'IBM', 'MSFT', 'ZM']
titles = ["Google", "NVIDIA", "AMD", "Intel", "Tesla", "IBM", "Microsoft", "Zoom"]

# Fetch and preprocess data for each stock
list_of_dataframes = [fetch_and_preprocess(stock, '2020-01-01', '2023-01-01') for stock in stocks]

# Calculate returns for subsequent plots
returns = pd.DataFrame({title: df["Adj Close"] for title, df in zip(titles, list_of_dataframes)}).pct_change().dropna()

# Plotting
plot_attributes(list_of_dataframes, titles)
plot_daily_return_distribution(list_of_dataframes, titles)
plot_risk_vs_expected_returns(returns, titles)
plot_correlations(returns)

plt.show()

Conclusion

While our analysis provides valuable insights, we should acknowledge their limitations; macroeconomic indicators, companies’ fundamentals, and external market forces are not factored in. These metrics are essential when creating a comprehensive investment strategy.

Moreover, we could go further with our analysis by creating more advanced financial models like the Efficient Frontier one or by leveraging machine learning algorithms. These enhancements could help us uncover patterns and/or trends imperceptible to traditional financial analysis.

We now have a good starting point for stock market analysis. Reproduce, compare, change industries, build from this Python script. See you next time!

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow and clap for more full Python scripts.

Follow us on Substack

The A-Z of Coding Your Way Through Stock Market Analytics was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Accurately predicting the prices of stocks or cryptocurrencies is a coveted skill. When dealing with time series forecasting, it is essential to have a baseline model that serves as a benchmark against which we can compare the performance of more sophisticated models.

In a previous article, we covered the random binary prediction model as a baseline for predicting the stock price of Dassault Systèmes. This model, rooted in random chance, helped us evaluate the efficacy of more advanced predictive models.

Today we will have a look at another fundamental baseline model: the naive persistence model. This model predicts that the future price of an asset will be the same as its most recent price in the context of finance and trading. Unlike the random binary prediction model, the naive persistence model does not rely on randomness. Hence, the omission of np.random.seed() in our implementation since no random numbers are generated.

This article will guide you step by step in implementing and evaluating a naive persistence model. We will focus on the price of Bitcoin.

Outline:

• Part 1. Implementing the naive persistence model
• Part 2. Understanding and evaluating the naive persistence model

Although we’ll use real market data, please keep in mind that this article is a tutorial, not financial advice, and aims to enhance our finance knowledge and Python skills.

Part 1. Implementing the naive persistence model

The naive persistence model is straightforward and does not account for market dynamics or historical trends. It takes the assumption that future prices will mirror current prices. The naive persistence model predicts… persistence in price. Tomorrow’s Bitcoin price will be the same as it is today!

The random binary prediction model employs random chance to predict prices movements. The naive persistence model predicts persistence in price.

import pandas as pd
import yfinance as yf
from sklearn.metrics import mean_squared_error
from math import sqrt

# Retrieving BTC prices
data = yf.download("BTC-USD", start="2017-01-01", end="2023-01-01")
btc_prices = data['Close'].values

# We split the data to get the training and testing sets
train, test = btc_prices[0:-10], btc_prices[-10:]

# Naive persistence model
predictions = train[-10:]

# Evaluating the model
rmse = sqrt(mean_squared_error(test, predictions))
print('RMSE: %.3f' % rmse)

Part 2. Understanding and evaluating the naive persistence model

We first fetch Bitcoin prices from Yahoo Finance. The data is then split into training and testing sets.

Here we have:

• train that contains all the price data except for the last 10 closing prices.
• test that contains those last 10 closing prices.

The naive persistence model then “predicts” that the next 10 prices will be the same as the last 10 observed prices in our training set. Persistence assumption is in action! In our code, the last 10 points (closing prices) of train are taken as predictions.

Evaluating the naive persistence model

To recap, we have the following arrays:

• test that contains the actual values (last 10 true prices).
• predictions that contains the predicted values (last 10 prices from the training set).

We evaluate the model with the root mean squared error or RMSE. It’s simply the square root of the mean squared error or MSE.

The mean squared error or MSE measures the average of the squares of the errors, i.e., the average squared difference between the estimated values (the predicted prices) and the actual value (the true prices).

Diving into RMSE

The RMSE is a performance indicator. It gives an estimate of how well a model is able to predict the target value, meaning that it gives us an indication of how accurate our predictions are compared to the actual values. It serves as a baseline metric.

The lower the RMSE, the better the model and its predictions. A higher RMSE indicates that on average the predictions are deviating more from the actual values, implying larger errors between the predicted and actual values: the RMSE is sensitive to the scale of the errors.

Note that the RMSE gives higher weight to larger errors. This means that the RMSE is useful when large errors are undesirable. In the context of predicting the price of bitcoin, we are particularly interested in minimizing large prediction errors due to the potential significant impacts on trading decisions.

Keep in mind that a “good” or “acceptable” RMSE depends on the context and the specific application. Sometimes a model with a relatively high RMSE might provide valuable insights.

Interpretation

We get an RMSE (Root Mean Squared Error) of 514.714. It indicates that on average the model’s predictions are approximately 514.714 units away from the actual observed values. Here, we are trying to predict the price of Bitcoin so the model’s predictions are on average 514.714 USD off.

We now have our benchmark metric. In the future, more sophisticated models should aim to have a lower RMSE to improve predictive accuracy.

Remember, the RMSE provides valuable insights into a model’s performance but decisions should be made holistically!

Moving Forward

To sum up, the naive persistence model can be used as an essential baseline for forecasting. The model assumes that future prices will mirror current ones and offers a starting point against which we can evaluate more complex models. Always refer back to it to ensure that newer models provide added predictive value!

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow and clap for more full Python scripts.

You can also follow FinancePy on Substack

Ressources

“Mean Squared Error (MSE) | Lesson 9.1.5.” ProbabilityCourse.com, https://www.probabilitycourse.com/chapter9/9_1_5_mean_squared_error_MSE.php. Accessed 05/10/2023.

Naive Persistence Model: A Baseline Forecasting Technique in Quantitative Finance was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Baseline models are essential to building accurate and profitable trading strategies. They serve as the starting point for any complex and more advanced models. Indeed, how can we measure the performance of our newly created strategy without a benchmark model for comparison?

The goal of a baseline model is to establish a benchmark against which we can compare the performance of more sophisticated models.

There are several baseline models that we can pick from in the context of stock price prediction. This article will focus on random binary prediction modeling.

This model predicts one of two possible outcomes with an equal probability of 50%: stock price will go up, or down. We refer to the principle of random chance when using the random binary prediction model.

This article will guide you step by step in implementing, evaluating, and visualizing a baseline model. We will focus on the stock price of Dassault Systèmes (ticker: DSY).

Outline

• Part 1. Fetching Dassault Systèmes stock price data and preprocessing it
• Part 2. Implementing Single Run Baseline Model
• Part 3. Exploring Variability in Baseline Model
• Part 4. Visualizing the Baseline Accuracies

Although we’ll use real market data, please keep in mind that this article is a tutorial, not financial advice, and aims to enhance our finance knowledge and Python skills.

Part 1. Fetching Dassault Systèmes stock price data and preprocessing it

We fetch the stock data from Yahoo Finance.

# Importing Libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score
import yfinance as yf

# Fetching Dassault Systèmes data
ds_data = yf.download('DSY.PA', start = '2010-01-01', end = '2023-01-01')

ds_data

# Calculating the daily return
ds_data['Return'] = ds_data['Close'].pct_change()

# Drop NaN values
ds_data = ds_data.dropna()

# Let's have a look
ds_data

Part 2. Implementing Single Run Baseline Model: the random binary prediction model

# Setting the random seed for reproducibility
np.random.seed(44)

# We then create random predictions: 1 for price increase, 0 for decrease / no change
random_predictions = np.random.randint(0, 2, len(ds_data['Return']))

Let’s take a moment to understand the random seed concept.

The seed is an initial number that we set — it could be anything (123, 0, or 44) — for the computer to generate a “random” number. By defining a specific seed, the sequence of random numbers the computer will generate will be the same, i.e., our results can be reproduced.

If we didn’t define a seed, the results would change every time we run the code. We would not be able to compare different models.

Now let’s look at the randint function that generates random integers.

• 0: start of the interval. Generated integers will be greater than or equal to 0.
• 2: end of the interval. Generated integers will be less than 2.
• len(ds_data[‘Return’]): Determines how many random integers to generate. For each entry in the Return variable a random integer will be created.

Application

Let’s say ds_data[‘Return’] has 5 entries. We will generate 5 random integers between 0 (inclusive) and 2 (exclusive), for example [1, 0, 1, 1, 0]. We would thus have [increase, decrease, increase, increase, decrease] for the stock price movements.

Why do we generate these random predictions? To compare them with the actual price movements and see how well a completely random guess would perform.

This helps us understand whether future complex models are genuinely predictive or merely performing as well as random chance.

# We then convert actual returns to binary: 1 for increase, 0 for decrease / no change
# Application np.where(condition, x, y)
actual_binary = np.where(ds_data['Return'] > 0, 1, 0)

This is the binary representation of the stock price going up or not. With 1 representing an increase in Dassault Systèmes’ stock price and 0 a decrease or no change.

For instance, this binary array will often be used as the true values to train a classification model. It will also be used to assess accuracy by comparing it with the predictions random_predictions.

# Now let's calculate the accuracy score
baseline_accuracy = accuracy_score(actual_binary, random_predictions)
print(f'Baseline model accuracy: {baseline_accuracy * 100:.2f}%')

The accuracy score is the ratio of the number of correct predictions to the total number of predictions.

actual_binary: contains the actual (true) values, ie. whether the stock price really went up (1) or not (0) for each day.

random_predictions: contains the predicted (random guesses in this baseline model case) values, ie. our model’s prediction regarding whether the stock price went up (1) or not (0) for each day.

The accuracy score is a decimal between 0 and 1: 1 for perfect accuracy (all predictions were correct) and 0 for no accuracy (all predictions were incorrect).

Interpreting 50.08% accuracy

Our score of 50.08% is what we might expect for binary classification; predictions essentially being a “coin flip”. We are therefore close to random. The 0.08% might indicate a tiny bit of predictive power but it’s too marginal to be considered as such and is probably due to random chance.

This being our baseline model, more complex ones should ideally achieve a higher accuracy.

Part 3. Exploring Variability in Baseline Model

We have calculated the accuracy score (50.08%) for a SINGLE run of random predictions against actual data. Let’s run it 1000 times with different random seeds.

The process of running 1000 random predictions and visualizing the distribution of accuracy scores is important. Indeed, this process will establish a distribution of accuracies we might expect from random guesses, build confidence in our baseline by observing the distribution, and finally inform us about the statistical significance of the results from any future developed models.

# Create 1000 random baseline accuracies
baseline_accuracies = []

# Setting the seed inside the loop to get different accuracies
for _ in range(1000):
    np.random.seed(_)
    random_preds = np.random.randint(0, 2, len(ds_data['Return']))
    baseline_accuracies.append(accuracy_score(actual_binary, random_preds))

Part 4. Visualizing the Baseline Accuracies

# Plotting
plt.figure(figsize=(12, 6))
plt.hist(baseline_accuracies, bins=30, color='skyblue', edgecolor='k')
plt.axvline(x=np.mean(baseline_accuracies), color='red', linestyle='--')
plt.title('Baseline Model Accuracies Distribution')
plt.xlabel('Accuracy')
plt.ylabel('Frequency')
plt.grid(axis='y')
plt.show()

Where do we go from here?

Our baseline model serves as a crucial reference point going forward. We now have a benchmark against which we can evaluate more complex and sophisticated models. In the future, a model that does not significantly outperform our baseline model might not be adding predictive insights.

Start building on this foundation: investigate financial indicators and key metrics that would enhance the predictive power of more complex models, explore different predictive models, look at risk management… The path is now paved towards crafting profitable quantitative trading strategies.

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow FinancePy for more full Python scripts.

You can also follow FinancePy on Substack

With over ten thousand cryptocurrencies listed on CoinMarketCap, the task of categorizing each one into a specific and accurate universe is daunting, if not nearly impossible. It’s an oversimplification to pigeonhole a cryptocurrency into just one universe given the multifaceted nature of digital assets and the rapid pace of development in the blockchain industry. Yet, the importance of establishing clear and accurate universes cannot be overstated; they are often the key ingredient in making profitable trading models and optimal portfolio allocations.

Meticulously defined universes can tremendously change the way we see the market, how we trade, and how we tweak models.

Now, everyone has heard of key sectors and categories in crypto, and everyone has bet on a trending universe. But not so many can properly define the DeFi universe or be ultra specific about an Enterprise-solutions sub-universe. And that’s okay.

However, to truly stand out and gain a competitive edge with our trading models, it’s crucial to start crafting custom universes. Indeed, relying on conventional universes and categorizations might leave potential opportunities unexplored. But they can still help us as a starting point. By fetching CoinMarketCap’s tags and integrating in-depth industry knowledge, traders can easily (and rapidly) define their own unique universes.

Traders should define unique universes, tailor-made to their investment thesis and market outlook.

This custom-made approach not only offers a more refined lens to understand the industry but can lead to significant advantage. Note that defining a personalized universes demands research and knowledge, and discretionary decision making will be needed. However, in these times of “systematic” trading models and AI-driven strategies, it could be interesting to tweak our models based on our understanding of the crypto industry.

Let’s set the stage for innovative personalized crypto universes and potentially more profitable trading strategies.

Although we’ll use real market data, please keep in mind that this article is a tutorial, not financial advice, and aims to enhance our finance knowledge and Python skills.

Part 1. Fetching All Tags for the Top 100 Coins from CoinMarketCap

You will need to have a FREE CoinMarketCap account. Go to this link and select the free API plan. You will then have your own personal API dashboard where you will be able to fetch your personalized CoinMarketCap API key. Just save it and replace ‘YOUR API KEY’ in the following code if you are following along.

To kick things off, we’ll tap into the CoinMarketCap API to retrieve all available tags.

The DataFrame will showcase the top 100 coins, their respective tags, and a placeholder for a future ‘universe’ variable.

import requests
import pandas as pd

# YOUR API KEY FROM COINMARKETCAP
api_key = 'YOUR API KEY'

# URL for the CoinMarketCap endpoint. We fetch the top 100 coins
url = 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest'

# Our request
headers = {'X-CMC_PRO_API_KEY': api_key}
parameters = {'start': '1', 'limit': '100', 'convert': 'USD'}

# Sending the request
response = requests.get(url, headers = headers, params = parameters)

# '200' if the request is successful
if response.status_code == 200:
    data = response.json()['data']
    
    rows = []

    # Iterate through the top 100 coins
    for rank, crypto in enumerate(data, 1):
        name = crypto['name']
        symbol = crypto['symbol']
        tags = crypto['tags'] if 'tags' in crypto else []
        quote = crypto['quote']['USD']
        market_cap = "${:,.0f}".format(quote['market_cap'])
        price = "${:,.1f}".format(quote['price'])

        # Collecting each row as a dictionary
        rows.append({
            'Rank': rank,
            'Name': name,
            'Symbol': symbol,
            'Market Cap': market_cap,
            'Price': price,
            'Tags': ", ".join(tags),
            'Universe': 'Placeholder'  # We add the 'Universe' column. This is where you will custom your universe
        })

    df = pd.DataFrame(rows)

else:
    print(f"Error fetching data: {response.status_code}")

We can see that each coin has several tags, like ‘mineable’, ‘pow’, ‘smart-contracts’, ‘payments’, ‘solana-ecosystem’, or ‘winklevoss-capital-portfolio’.

CoinMarketCap’s tags provide valuable information that will help us discretionarily define universes for digital assets.

For instance, Ethereum has the tag ‘layer-1’ similar to BNB. But should we categorize both Ethereum and BNB into the ‘layer-1’ universe? This is where discretionary decisions come into play, and depending on different investment theses, the answer (and thus the universes) might differ.

Subscribe to get FinancePy discretionary universes.

Part 2. Analyzing the Occurrences of Each Tag

Let’s dive deeper into CoinMarketCap’s tags and analyze the occurrences of each tag.

from collections import Counter

# First we extract the tags from 'df' and split it by ', '
all_tags = df['Tags'].str.split(', ').tolist()

# Flatten the list of lists
flattened_tags = []
for sublist in all_tags:
    for tag in sublist:
        flattened_tags.append(tag)

# Then we count the occurrences of each tag
tag_counts = Counter(flattened_tags)

# We create a DataFrame for better visualization
tag_counts_df = pd.DataFrame(tag_counts.items(), columns = ['Tag', 'Count']).sort_values(by = 'Count', ascending = False)

tag_counts_df.head(50)

What Now?

It’s interesting to see that many tags represent several well-known portfolios. The ‘defi’ tag appears the most with a count of 26.

We could simply get the top coins by marketcap from each of the top 10 portfolios and create a new ‘top-portfolio’ universe. Or we could define new ‘defi’ sub-universes and base our strategy on a specific ‘defi’ sub-universe.

The possibilities are endless. Explore them and discover untapped potential.

Thanks for reading and stay tuned for more articles! If you enjoyed reading this article, please follow FinancePy for more full Python scripts.

You can also follow FinancePy on Substack

You Need Personalized Crypto Universes for Optimal Profits was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

While the intertwined worlds of finance and Python are undeniably fascinating, knowing where to start can be overwhelming and challenging.

If you feel lost in this jungle of financial concepts and incomplete Python scripts, FinancePy could be your new go-to resource. This article will guide you step by step — and provide the full Python script — to retrieve Bitcoin OHLCV data from Kraken’s API for the last 720 days, compute key financial metrics such as the log return or rolling averages, and finally help you visualize the results.

This article serves as a primer and aims to equip anyone with the foundational skills to create their own simple strategy in the future.

See this article as your gateway to “systematic” finance and discover how you can leverage the power of Python to create your own trading strategy from the ground up. More advanced articles will follow.

Although we’ll use real market data, please keep in mind that this article is a tutorial, not financial advice, and aims at enhancing our finance knowledge and Python skills. Note that this article focuses on Bitcoin as our chosen asset but that the following script can be applied to other assets of your choice.

Part 1: Fetching 720 Days of Historical Data from Kraken

We first import our required libraries and then initialize our public API. Here we are specifically fetching data from Kraken but note that the “ccxt” Python library can be used to fetch data from other exchanges like Binance. Be aware that symbol and timeframe formats may vary between exchanges, therefore you might need to check “ccxt” documentation before fetching new data from other exchanges.

We then define the asset’s symbol and the timeframe. We are looking for Bitcoin “BTC” traded in USD on Kraken “BTC/USD” and daily data. At the time of writing this article, we fetched the data on October 1, 2023. Please be aware that when fetching data at a later date results will change.

`fetch_ohlcv` retrieves the OHLCV (Open, High, Low, Close, Volume) data for the symbol and timeframe specified: OHLCV data is fundamental for conducting various types of technical analysis or creating a strategy.

Here, our DataFrame `data` has 720 entries. 1 entry represents 1 day. It’s important to determine the number of days of historical data available for technical indicators and backtesting purposes and to look at the data type of each of our variables.

import ccxt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Initializing the connection with Kraken
kraken = ccxt.kraken()

# We determine the symbol and desired timeframe
symbol = 'BTC/USD'
timeframe = '1d'

# We extract OHLCV data through `fetch_ohlcv()`
ohlcv = kraken.fetch_ohlcv(symbol, timeframe)

# We create the DataFrame `data` from our `ohlcv` array
data = pd.DataFrame(ohlcv, columns = ['timestamp', 'open', 'high', 'low', 'close', 'volume'])
data['timestamp'] = pd.to_datetime(data['timestamp'], unit = 'ms')
data.set_index('timestamp', inplace = True)
data

# Let's get more information from our data
data.info()
data.describe()

Part 2: Calculating Advanced Financial Metrics and Technical Indicators

Now that we have our Bitcoin `data` ready, we get to the interesting part, calculating key financial metrics:

1. Logarithmic Returns (log return)
2. Rolling Volatility
3. 50-day and 200-day Rolling Averages
4. Sharpe Ratio

Understanding Our Variables

1. Logarithmic Returns: Unlike raw price differences, logarithmic returns give a consistent metric to compare returns over time. You calculate it by taking the natural log of the ratio of consecutive prices. Log returns are important because they account for the compounding effect. They also give a more accurate representation of returns over time. You can see how we calculate the log returns in the code below.

Cool characteristics about log returns!

• Compounding: They can be added together over time, which is not the case for simple returns.
• Statistical Properties: They are approximately normally distributed for many assets.
• Stability: They are more stable and less skewed than simple returns.

Note that for small return values the difference between log returns and simple returns is minimal… But as returns become larger, the difference is more pronounced.

2. Rolling Volatility: The rolling volatility measures the degree of variation of a trading price series over time. Here, our 21-day rolling volatility is the standard deviation of the log returns over the past 21 days. We get a moving snapshot of how volatile the Bitcoin prices have been in the past two years and can assess its potential market risks.

3. 50-day and 200-day Rolling Averages: These metrics smooth out our price data to reveal underlying trends. They’re crucial in trend-following strategies, helping us identify potential buy or sell opportunities based on crossovers or relative positions of the Bitcoin price to these averages.

4. Sharpe Ratio: This is a measure of risk-adjusted return. It describes how much excess return you can expect to receive for the extra volatility of holding a riskier asset, like Bitcoin in this case. A higher Sharpe ratio indicates a better risk-adjusted performance. The formula involves subtracting the risk-free rate from the asset’s return and then dividing by its volatility. This gives us a sense of the ‘price’ of the risk taken to achieve a certain level of return.

In this tutorial we arbitrarily set the risk-free rate to 1% but just know for now that the choice of the risk-free rate depends on the analysis. Often, in U.S. markets, the three-month U.S. Treasury bill is set as the risk-free rate of return, given the very low risk of default by the American government. We will cover this topic in a next article.

Focus: As of June 30, 2023, the S&P 500 Portfolio Sharpe ratio is 0.88. (source Investopedia).

# Computing log returns
data['log_return'] = np.log(data['close'] / data['close'].shift(1))

# Computing rolling volatility
data['rolling_volatility'] = data['log_return'].rolling(window=21).std()

# Computing 50-day and 200-day moving averages
data['50_MA'] = data['close'].rolling(window=50).mean()
data['200_MA'] = data['close'].rolling(window=200).mean()

# Computing sharp ratio
risk_free_rate = 0.01  
annualized_sharpe_ratio = (data['log_return'].mean() - risk_free_rate) / data['log_return'].std() * np.sqrt(252) # or 365 days in the case of assets traded all year

Rolling Averages Focus

Let’s take a moment to talk about rolling averages, also known as moving averages. They are a type of data smoothing technique. By averaging out data over specific intervals, rolling averages help in revealing underlying trends and patterns. These are extremely useful to get a first understanding of our data.

The ‘window size’ like 50 days or 200 days in our case, determines the number of days to average and also defines the lag from the data. A 50-day rolling average will use the previous 50 days’ data points to compute an average for a specific day, thus giving a smoother line that can potentially signal long-term trends. A 200-day rolling average is considered even more long-term.

In financial analysis, these rolling averages have multiple purposes:

1. Trend Identification: A rising moving average typically suggests an uptrend, while a falling moving average indicates a downtrend.
2. Support and Resistance Levels: In chart analysis, moving averages can act as support or resistance lines.
3. Signal Generation: When a short-term moving average (like the 50-day MA) crosses above a long-term moving average (like the 200-day MA), it’s considered a bullish signal, and vice versa.

If you wanted to create a trading strategy, or just follow some key metrics for your technical analysis, the rolling averages can be a good starting point.

Understanding NaNs in our Data

In our DataFrame ‘data’, we can observe some entries with NaN (Not a Number). These are a result of certain calculations; the rolling metrics.

This concept is straightforward to understand. When computing a 50-day rolling average, the first 49 entries won’t have a value because they don’t have 50 preceding days to average from. Therefore, these entries are populated with NaN. This is a common occurrence in time series analysis.

Part 3: Visualizing our data and metrics

We plot BTC closing prices as well as the moving averages for the period. It can also be interesting to visualize the average price and volatility of the asset. We can represent them by dotted red lines.

# Background grid
plt.style.use('seaborn-whitegrid')

# Plotting BTC closing prices (last 720 days) and average with the 50 and 200 MAs
average_price = data['close'].mean()

plt.figure(figsize = (14, 7))
data[['close', '50_MA', '200_MA']].plot(ax = plt.gca(), title = "BTC/USD Price Trends & Moving Averages")
plt.axhline(average_price, color = 'red', linestyle = '--', label = f"BTC Average Price: ${average_price:.2f}")
plt.ylabel("Price (USD)")
plt.legend()
plt.show()

# Visualizing Rolling Volatility with average volatility
average_volatility = data['rolling_volatility'].mean()

plt.figure(figsize = (14, 7))
data['rolling_volatility'].plot(title = "Bitcoin's 21-Day Rolling Volatility")
plt.axhline(average_volatility, color = 'red', linestyle = '--', label = f"Average Volatility: {average_volatility:.6f}")
plt.ylabel("Volatility")
plt.legend()
plt.show()

Conclusion

These building blocks, though “systematic”, are just the tip of the iceberg. You now know how to fetch live data using the ccxt library, calculate key trading metrics, and visualize them.

With this foundational knowledge, you are now better equipped to tackle more advanced topics. The real challenge, however, lies in integrating financial concepts with python programming to uncover profitable trading strategies. It takes time, practice and extensive research, but it’s a fascinating and rewarding journey.

In future articles, we will explore backtesting, the discovery and tweaking of trading features, selecting a trading universe, and much more.

Thanks for reading and stay tuned for more articles in this Toolkit series!

If you enjoyed reading this article, please follow FinancePy for more full Python scripts.

You can also follow FinancePy on Substack

Ressources:

Eng Guan. (2023, Mar 3). Magic of Log Returns: Concept — Part 1. Updated Mar 10. Retrieved on September 30, 2023, from allquant.

Hayes, A. (2023, May 21). What Is the Risk-Free Rate of Return, and Does It Really Exist? Reviewed by Cierra Murry. Fact checked by Pete Rathburn. Investopedia. Consulted on September 29, 2023. Retrieved from investopedia.

Fernando, J. (2023, May 11). Sharpe Ratio: Definition, Formula, and Examples. Reviewed by Margaret James. Fact checked by Katrina MuniChiello. Investopedia. Consulted on September 30, 2023. Retrieved from investopedia.

Building Blocks for Python-Driven Trading Analysis. A Toolkit Series was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

A comprehensive tutorial to coding your first trading strategy.

Introduction

Creating a personal trading strategy is becoming more and more popular amongst at-home traders and/or Python enthusiasts. This article will go through the complete lifecycle of a trading strategy: starting from procuring market data, computing technical indicators, generating trading signals and finally assessing the efficacy of the strategy.

We will use $ETH prices in USD from Kraken’s API and build two strategies based on the Moving Average Convergence/Divergence (MACD) and the Awesome Oscillator (AO).

By the end of this article, one should have a robust foundation to build on, and the capability to test its own trading strategies and assess their potential.

That said, it’s critical to note that the strategies we are deploying here are simplified versions designed for demonstrative purposes. There are additional factors that a pragmatic trading strategy ought to consider, such as trading costs, market influence, risk management, and more. Moreover, tangible trading conditions, like existing portfolio holdings, can significantly influence the outcome of a strategy. Although we’ll use real market data, keep in mind that this article is a tutorial, not financial advice, and aims at enhancing our Python skills.

With this in mind, let’s create our own trading strategy!

Part 1: Fetching historical data from Kraken

We first import our required libraries and then initialize our public API. While we are fetching data from Kraken, note that the “ccxt” Python library can be used to fetch data from multiple exchanges like Binance. Be aware that symbol and timeframe formats may vary between exchanges, consequently you might need to check “ccxt” documentation before fetching new data from other exchanges.

We define the symbol and the timeframe. We are looking for Ethereum “$ETH” traded in USD on Kraken “ETH/USD” and daily data.

“fetch_ohlcv” retrieves the OHLCV (Open, High, Low, Close, Volume) data for the symbol and timeframe specified: OHLCV data is fundamental for creating a strategy or conducting various types of technical analysis.

import ccxt
import pandas as pd

# Kraken API
exchange = ccxt.kraken()

# We define the symbol and timeframe
symbol = 'ETH/USD'
timeframe = '1d'

# We fetch OHLCV data
ohlcv = exchange.fetch_ohlcv(symbol, timeframe)

# We first convert to DataFrame then to Timestamp for a more readable format
df = pd.DataFrame(ohlcv, columns=['Timestamp', 'Open', 'High', 'Low', 'Close', 'Volume'])
df['Timestamp'] = pd.to_datetime(df['Timestamp'], unit='ms')
df.set_index('Timestamp', inplace=True)

# We now have our DataFrame
df

Here, let’s keep in mind that our DataFrame “df” has 720 entries. 1 entry represents 1 day. It’s important to determine the number of days of historical data available for technical indicators and backtesting purposes.

Part 2: Calculating the MACD and the AO

We now calculate the MACD and AO from our fetch data. The definitions below come from Investopedia and IG International. You will find the links in the ressources section.

“The Moving Average Convergence/Divergence (MACD) is a trend-following momentum indicator that shows the relationship between two exponential moving averages (EMAs) of a security’s price. The MACD line is calculated by subtracting the 26-period EMA from the 12-period EMA.

The result of that calculation is the MACD line. A nine-day EMA of the MACD line is called the signal line, which is then plotted on top of the MACD line, which can function as a trigger for buy or sell signals.” — Investopedia

For the MACD, we compute the MACD Line, the Signal Line, and the MACD Histogram in order to visualize it completely and develop a proper strategy.

“The Awesome Oscillator (AO) is a market momentum indicator which compares recent market movements to historic market movements. It uses a zero line in the centre, either side of which price movements are plotted according to a comparison of two different moving averages.” — IG International

For the AO, we compute a histogram anchored around a zero line.

We calculate both indicators using the “ta” Python library.

# Calculate MACD Line, Signal Line and MACD Histogram
macd = ta.trend.MACD(df['Close'])

df['macd_line'] = macd.macd()  # MACD Line
df['macd_signal'] = macd.macd_signal()  # Signal Line
df['macd_hist'] = macd.macd_diff()  # MACD Histogram (MACD Line - Signal Line)

# Calculate Awesome Oscillator
ao = ta.momentum.AwesomeOscillatorIndicator(df['High'], df['Low'])

df['ao'] = ao.awesome_oscillator()  # Awesome Oscillator

df

Part 3: Dropping the NaN values from our DataFrame

This is a brief but crucial part of the tutorial. Given that the data for MACD and AO can’t be calculated due to the absence of historical prices before 2021–05–13, we drop all the NaN values from our DataFrame “df”. Always understand an indicator before adding it to your strategy!

# Drop NaN values
df.dropna(inplace=True)
df.info()

We now have prices for 687 days: from the 2021–06–15 to the 2023–05–02. Note that if you reproduce this code at home, you will fetch data that will have a different timeframe from this article (since Kraken only allows you to get data from the last 720 days, there will be a lag). But not to worry, it’s still the same process!

Part 4: Plotting the ETH prices and the indicators

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, ax = plt.subplots(3, figsize=(12,12), dpi=200)

# Plot ETH prices
ax[0].plot(df.index, df['Close'], label='ETH/USD')
ax[0].set_title('ETH/USD Prices - Last 687 days')
ax[0].legend()
ax[0].set_xlim([df.index.min(), df.index.max()])

# Plot MACD Line, Signal Line and Histogram
ax[1].plot(df.index, df['macd_line'], label='MACD Line') # Plot MACD Line and Signal Line
ax[1].plot(df.index, df['macd_signal'], label='Signal Line') # Plot MACD Line and Signal Line
ax[1].bar(df.index, df['macd_hist'], alpha=0.5, label='MACD Histogram') # Plot MACD Histogram as bar plot
ax[1].set_title('MACD')
ax[1].legend()
ax[1].set_xlim([df.index.min(), df.index.max()])

# Plot Awesome Oscillator
ax[2].bar(df.index, df['ao'], alpha=0.5, label='Awesome Oscillator', color='gray')
ax[2].set_title('Awesome Oscillator')
ax[2].legend()
ax[2].set_xlim([df.index.min(), df.index.max()])

# Set date format
date_format = mdates.DateFormatter('%b %y')
ax[0].xaxis.set_major_formatter(date_format)
ax[1].xaxis.set_major_formatter(date_format)
ax[2].xaxis.set_major_formatter(date_format)

# Show the plot
plt.tight_layout()
plt.show()

Part 5: Generating trading signals

We’ll define two strategies based on the MACD and AO signals.

Strategy 1: Buy when both MACD and AO are positive, sell when they’re both negative.

Strategy 2: Buy when MACD crosses above the signal line and AO crosses above zero, sell when MACD crosses below the signal line and AO crosses below zero.

import numpy as np

# Strategy 1
# Generating the buy "signal1"
df['signal1'] = np.where((df['macd_line'] > df['macd_signal']) & (df['ao'] > 0), 1, 0)
# Generating the "sell_signal1"
df['sell_signal1'] = np.where((df['macd_line'] < df['macd_signal']) & (df['ao'] < 0), 1, 0)

# Strategy 2
# Generating the buy "signal2" 
df['signal2'] = np.where((df['macd_line'] > df['macd_signal']) & (df['macd_line'].shift() < df['macd_signal'].shift()) & (df['ao'] > 0) & (df['ao'].shift() < 0), 1, 0)
# Generating the "sell_signal2"
df['sell_signal2'] = np.where((df['macd_line'] < df['macd_signal']) & (df['macd_line'].shift() > df['macd_signal'].shift()) & (df['ao'] < 0) & (df['ao'].shift() > 0), 1, 0)

# Counting the buy/sell signals
num_signals1 = df['signal1'].sum()
num_sells1 = df['sell_signal1'].sum()
num_signals2 = df['signal2'].sum()
num_sells2 = df['sell_signal2'].sum()

print(f"Number of buy signals in Strategy 1: {num_signals1}")
print(f"Number of sell signals in Strategy 1: {num_sells1}")
print(f"Number of buy signals in Strategy 2: {num_signals2}")
print(f"Number of sell signals in Strategy 2: {num_sells2}")

In summary, both strategies rely on the MACD Line, Signal Line, and AO value to generate buy and sell signals. Strategy 1 is based on simple intersections of the MACD Line and Signal Line, along with the AO value being above or below zero. Strategy 2, on the other hand, focuses on the crossing points of the MACD Line and Signal Line, as well as the crossing points of the AO value above and below zero.

Strategy 2 is more sensitive because it is looking for the points at which the MACD Line crosses the Signal Line and when the AO value crosses zero. These crossing points typically represent changes in market momentum, which is why the strategy is said to be sensitive to changes in momentum.

Part 6: Plotting the signals on the graph

fig, ax = plt.subplots(4, figsize=(12, 30))

# Plot ETH prices
ax[0].plot(df.index, df['Close'], label='ETH/USD')
ax[0].scatter(df[df['signal1'] == 1].index, df[df['signal1'] == 1]['Close'], color='g', marker='^', label='Buy Signal - Strategy 1')
ax[0].scatter(df[df['sell_signal1'] == 1].index, df[df['sell_signal1'] == 1]['Close'], color='r', marker='v', label='Sell Signal - Strategy 1')
ax[0].scatter(df[df['signal2'] == 1].index, df[df['signal2'] == 1]['Close'], color='b', marker='o', label='Buy Signal - Strategy 2', alpha=0.7)
ax[0].scatter(df[df['sell_signal2'] == 1].index, df[df['sell_signal2'] == 1]['Close'], color='orange', marker='x', label='Sell Signal - Strategy 2', alpha=0.7)
ax[0].set_title('ETH/USD Prices - Last 687 days')
ax[0].legend()
ax[0].set_xlim([df.index.min(), df.index.max()])

# Plot MACD Line, Signal Line and Histogram
ax[1].plot(df.index, df['macd_line'], label='MACD Line')
ax[1].plot(df.index, df['macd_signal'], label='Signal Line')
ax[1].bar(df.index, df['macd_hist'], alpha=0.5, label='MACD Histogram')
ax[1].set_title('MACD')
ax[1].legend()
ax[1].set_xlim([df.index.min(), df.index.max()])

# Plot Awesome Oscillator
ax[2].bar(df.index, df['ao'], alpha=0.5, label='Awesome Oscillator', color='gray')
ax[2].set_title('Awesome Oscillator')
ax[2].legend()
ax[2].set_xlim([df.index.min(), df.index.max()])

# Let's also set the appropriate date format
date_format = mdates.DateFormatter('%b %y')
for a in ax:
    a.xaxis.set_major_formatter(date_format)

# Plot
plt.tight_layout()
plt.show()

Part 7: Backtesting

To evaluate our strategies, we calculate the daily returns based on the generated buy and sell signals: we calculate the daily returns as the percentage change in the closing price.

Then, we calculate the returns for each strategy by multiplying the daily returns with the respective signals (shifted by one day to avoid forward-looking bias). Cumulative returns are then calculated by cumulatively multiplying the daily returns (plus one); it simulates the compounding of returns as if you reinvested the proceeds of each trade.

Strategy 2 generated only 1 buy and 2 sell signals. We won’t be backtesting this strategy.

We recommend using the “quantstats” Python library for detailed reports.

import quantstats as qs

# We calculate the daily returns
df['returns'] = df['Close'].pct_change()

# Strategy 1 returns
df['strategy1_returns'] = df['returns'] * df['signal1'].shift()
df['strategy1_cum_returns'] = (1 + df['strategy1_returns']).cumprod()

# Drop the NaN values
df.dropna(inplace=True)

# Let's print the report for Strategy 1
print("Strategy 1:")
qs.reports.full(df['strategy1_returns'])

Quantstats gives us the EOY returns, the distribution of monthly returns, daily returns, the rolling volatility (6-months), the rolling sharpe (6-months), the rolling sortino (6-months), and so on.

Here, we only got 720 historical prices from Kraken’s API and are currently using 687 for backtesting. It’s enough for our tutorial but keep in mind that when conducting a backtest you need to have data that includes all market conditions (bull markets, bear markets, periods of high volatility, periods of low volatility); therefore sometimes much more than 687 days! Indeed, a commonly recommended minimum for many strategies would be at least 5–10 years.

Also, in more advanced backtesting, you would ideally simulate the strategy as closely as possible to how it would be implemented in real trading conditions. Like keeping track of whether you’re currently holding a position or not. It would also include transaction costs, slippage, and other practical considerations.

And it’s done. We hope you now have a robust foundation to build new strategies and assess their potential!

Thanks for reading and stay tuned for more articles in this Python series!

Ressources:

Brian Dolan, “MACD Indicator Explained, with Formula, Examples, and Limitations”, Investopedia, March 15, 2023.

IG International, “A trader’s guide to using the awesome oscillator”, IG International, Updated Monthly.

QuantStats Library, QuantStats Documentation, last checked on May 10, 2023.

Ta Library, Ta Documentation, last checked on April 28, 2023.

Introduction

Cross-exchange Arbitrage was highly profitable in the early days of cryptocurrency trading. Simple models coded in Python allowed savvy traders to capitalize on price discrepancies between crypto exchanges. But as the market matures and models become more advanced, the question arises: Are there any cross-exchange arbitrage opportunities left?

Let’s focus on Binance and Kraken, two of the largest and most popular exchanges. We’ll obtain real market data from both their respective APIs. We will analyze Bitcoin ($BTC) prices in USD from April 20th, 2023, from 00:00:00 to 23:45:00, at 15-minute intervals.

This article will showcase how one can leverage the power of Python to analyze real-time data and determine the viability of arbitrage strategies in today’s crypto landscape. Although we’ll use real market data, keep in mind that this article is a tutorial, not financial advice, and aims at enhancing our Python skills. Join us as we delve into the fascinating realm of cross-exchange arbitrage using Python!

Part 1: Import libraries

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import requests
from datetime import datetime, timedelta

Part 2: Defining functions to fetch data from Binance and Kraken APIs

# This function fetches data from Binance API
def get_binance_data(symbol, interval, start_time, end_time):
    url = f"https://api.binance.com/api/v3/klines?symbol={symbol}&interval={interval}&startTime={start_time}&endTime={end_time}"
    response = requests.get(url)
    data = response.json()

    df = pd.DataFrame(data, columns=['Open time', 'Open', 'High', 'Low', 'Close', 'Volume', 'Close time', 'Quote asset volume', 'Number of trades', 'Taker buy base asset volume', 'Taker buy quote asset volume', 'Ignore'])
    df['Open time'] = pd.to_datetime(df['Open time'], unit='ms')
    df['Close time'] = pd.to_datetime(df['Close time'], unit='ms')
    return df[['Open time', 'Close time', 'Open', 'High', 'Low', 'Close', 'Volume']]

# This function fetches data from Kraken API
def get_kraken_data(pair, interval, since):
    url = f"https://api.kraken.com/0/public/OHLC?pair={pair}&interval={interval}&since={since}"
    response = requests.get(url)
    data = response.json()['result'][pair]

    df = pd.DataFrame(data, columns=['Open time', 'Open', 'High', 'Low', 'Close', 'Volume', 'Weighted average price', 'Number of trades'])
    df['Open time'] = pd.to_datetime(df['Open time'], unit='s')
    df['Close time'] = df['Open time'] + pd.to_timedelta(interval, unit='m')
    return df[['Open time', 'Close time', 'Open', 'High', 'Low', 'Close', 'Volume']]

The query parameters to get data from the APIs are not necessarily the same. For Binance, the query parameters are “symbol”, “interval”, “start_time”, “end_time”, while for Kraken they are “pair”, “interval”, “since”. The goal here is to create functions that will both return a DataFrame with the same desired columns.

Part 3: Fetching and merging data from both APIs

# Let's first define a function to convert a datetime object to timestamp in milliseconds (trading data usually is in milliseconds)
def datetime_to_timestamp(dt):
    return int(dt.timestamp() * 1000)

# Setting the date range for fetching our data
start_date = datetime(2023, 4, 19)
end_date = datetime(2023, 4, 22)

# Using our datetime object to timestamp function
start_timestamp = datetime_to_timestamp(start_date)
end_timestamp = datetime_to_timestamp(end_date)

# Fetching Bitcoin data from Binance and Kraken APIs
binance_data = get_binance_data('BTCUSDT', '15m', start_timestamp, end_timestamp)
kraken_data = get_kraken_data('XXBTZUSD', 15, start_timestamp)

# Using the "Open time" column as the key for merging both Binance and Kraken data
merged_data = pd.merge(binance_data, kraken_data, on='Open time', suffixes=('_binance', '_kraken'))

# Price discrepancies: We finish by calculating the price difference between the closing prices from Binance and Kraken
merged_data['Price difference'] = merged_data['Close_binance'].astype(float) - merged_data['Close_kraken'].astype(float)

# We then set the 20th of April from the DataFrame merged_data
filter_start = datetime(2023, 4, 20, 0, 0, 0)
filter_end = datetime(2023, 4, 20, 23, 45, 0)

# We filter the merged_data DataFrame
filtered_data = merged_data[(merged_data['Open time'] >= filter_start) & (merged_data['Open time'] <= filter_end)]
filtered_data

We now have our data for the 20th of April and have also calculated the price differences between the closing prices from Binance and Kraken. Let’s plot them.

Part 4: Plot the 15-minute prices discrepancies

fig, ax = plt.subplots(figsize=(12, 6), dpi=200)

ax.plot(filtered_data['Open time'], filtered_data['Close_binance'].astype(float), label='Binance', linewidth=2)
ax.plot(filtered_data['Open time'], filtered_data['Close_kraken'].astype(float), label='Kraken', linewidth=2)

ax.set_title('BTC 15-Minute Prices on Binance and Kraken (April 20, 2023)')
ax.set_xlabel('Time')
ax.set_ylabel('Price (USD)')
ax.legend()

plt.show()

The graph below plots the closing prices of $BTC from Binance and Kraken on the 20th of April 2023. The Binance and Kraken price trends are very similar, but they occasionally diverge. This disparity, called spread, is the cross-exchange arbitrage opportunity that traders capitalize on: buy BTC at a lower price on one exchange and sell at a higher price on the other, hence generating profit.

We could then directly plot the newly created variable “Price difference” but then the spread would be represented as a negative and positive value. We are however not interested in the direction but the magnitude of the difference between the prices. Therefore, we will create a line graph representing the absolute difference between the closing prices of the two exchanges. Let’s plot these price differences, let’s visualize the spread!

fig, ax = plt.subplots(figsize=(12, 6), dpi=200)

# We calculate the absolute difference between Binance and Kraken closing prices with the abs() function
plt.plot(filtered_data['Open time'], abs(filtered_data['Close_binance'].astype(float) - filtered_data['Close_kraken'].astype(float)), label='Spread Binance vs Kraken', color='green')

plt.title('BTC Price Spread: Binance vs Kraken (April 20, 2023) - Absolute difference')
plt.legend()

Part 5: Calculating the total spread for the day

In a perfect theoretical trading environment where one could capitalize from every spread, it would be possible to profit from the price discrepancies between Binance and Kraken. Let’s compute the sum of all the spreads. The total spread for the day is 922 USD. This figure is theoretical.

# We calculate the total spread for the day in an theoretical environment
total_spread = abs(filtered_data['Close_binance'].astype(float) - filtered_data['Close_kraken'].astype(float)).sum()

print(f"Total Spread for the day: {total_spread} USD")

Part 6: Introducing trading fees & Co

In real-world conditions there are several factors to keep in mind such as fees, slippage and other variables like the rapidity of the trading execution.

Exchanges like Binance and Kraken typically charge maker and taker fees. When you execute an arbitrage strategy, it’s vital to include theses fees in your profit calculations.

Maker fee: A maker is someone who places an order that doesn’t immediately match with an existing order on the order book. Instead, it “makes” liquidity by adding to the pool of open orders, waiting to be matched. As makers contribute to the overall liquidity of the market, their fees are generally lower than taker fees.

Taker fee: A taker is someone who places an order that is immediately filled by matching it with an existing order on the order book. Takers “take” liquidity from the market by reducing the number of open orders. As a result, taker fees are typically higher than maker fees.

Suppose you buy 1 BTC on Binance at a lower price and sell it on Kraken at a higher price. Placing a limit order to buy 1 BTC on Binance classifies you as a maker and you’ll have to pay a maker fee when the order is executed. Then, placing a market order on this 1 BTC on Kraken will classify you as a taker and you’ll have to pay a taker fee. Please refer to the chart below to see the different fee structures across exchanges.

When you execute an arbitrage strategy, it’s vital to include theses trading fees in your profit calculations. Indeed, the arbitrage opportunity may not generate a profit after taking into account the fees associated to both exchanges.

After examining the fee structures of both Binance and Kraken, we decided to apply an average 0.2% trading fee.

# We add and calculate the absolute difference and fees columns in our filtered_data DataFrame
filtered_data['Absolute Price Diff'] = abs(filtered_data['Close_binance'].astype(float) - filtered_data['Close_kraken'].astype(float))
filtered_data['Fees'] = 0.002 * (filtered_data['Close_binance'].astype(float) + filtered_data['Close_kraken'].astype(float))

# We create a new DataFrame with the desired columns using dictionary comprehension
arbitrage_df = pd.DataFrame({column: filtered_data[column] for column in ['Open time', 'Close_binance', 'Close_kraken', 'Absolute Price Diff', 'Fees']})

# We then rename the columns in the DataFrame 'Close_binance' and 'Close_kraken'
arbitrage_df.columns = ['Open time', 'Binance BTC', 'Kraken BTC', 'Absolute Price Diff', 'Fees']
arbitrage_df

Part 7: On which exchange should we buy? Sell?

Now, let’s generate buy and sell signals.

We will return “0” when Binance BTC price is superior to Kraken BTC price (buy on Kraken and sell on Binance)

We will return “1” when Kraken BTC price is superior to Binance BTC price (buy on Binance and sell on Kraken)

# np.where(condition, x, y) returns an array with the same shape as the condition
# If the condition is True, it returns the corresponding element from x, otherwise from y
signals_data = np.where(arbitrage_df['Binance BTC'] > arbitrage_df['Kraken BTC'], 0, 1)

# We create a new DataFrame to store the signals
# Set the index of signals_df to match the index of arbitrage_df
signals_df = pd.DataFrame(signals_data, columns=['BuyKrakenSellBinance'], index=arbitrage_df.index)

# We then add the signals to the arbitrage_df DataFrame
arbitrage_df = pd.concat([arbitrage_df, signals_df], axis=1)
arbitrage_df

Part 8: Executing a profitable trade

To finish, we have to determine if the arbitrage opportunity is profitable after accounting for trading fees.

If the absolute price difference is greater than the fees, set the value to “0” (execute the trade). This is a profitable trade !

If the absolute price difference is less than or equal to the fees, set the value to “1” (do not execute the trade)

# Create a new column 'Execute Trade' in the arbitrage_df DataFrame
arbitrage_df['Execute Trade'] = (arbitrage_df['Absolute Price Diff'] <= arbitrage_df['Fees']).astype(int)
arbitrage_df

# Let's then count the number of trade profitable (marked with "0")
number_of_profitable_trades = (arbitrage_df['Execute Trade'] == 0).sum()
print(f"Number of profitable arbitrage trades: {number_of_profitable_trades}")

There are unfortunately no trades that are profitable on the 20th of April for us. But nothing stops us from running this Python script every day!

We could also use this Python script on less liquid assets such as altcoins. Or pull data from other smaller exchanges where price differences can be important… We might catch, at last, a great cross-exchange arbitrage opportunity.

Thanks for reading and stay tuned for more articles in this Python series!

Ressources:

Huobi, “Crypto Arbitrage Opportunities: All About Cross-Asset And Exchange Arbitrage!”, medium, Aug 23, 2022.

Spencer Pao, “Quant Strategy: Arbitrage Trading Algorithm (Cross-Exchange)”, youtube, Nov 23, 2021.