Ensure you have the following set up:

• Pandas: Used for processing and working with tabular data
• Matplotlib: A library for data visualization
• mplfinance: A subset of Matplotlib specifically for financial data

As we’ll also be making calls to CoinGecko API’s paid /onchain endpoint, ensure you are subscribed and have generated your API key.

Step 1: How to Get Historical OHLCV Data with CoinGecko API

The core of our application involves getting OHLCV data over a given time interval (read more about the endpoint on CoinGecko API’s documentation). Let’s start by defining a function that wraps our desired functionality and input parameters.

@st.cache_data

def fetch_ohlcv_data(network_id, pool_id, interval="hour"):

   url = f"https://pro-api.coingecko.com/api/v3/onchain/networks/{network_id}/pools/{pool_id}/ohlcv/{interval}"

   response = requests.get(url, headers=HEADERS)

   if response.status_code == 200:

       return response.json()

   else:

       st.error(f"Failed to retrieve OHLCV data. Status code: {response.status_code}")

       return []

The JSON payload returned from above can be parsed and massaged into a pandas dataframe for easier processing. Let’s define a new function that does just this for use downstream in our graph components:

def parse_ohlcv_data(json_payload):

   # Extract OHLCV list and metadata from the payload

   ohlcv_list = json_payload["data"]["attributes"]["ohlcv_list"]

   metadata = json_payload["meta"]

   # Parse OHLCV data into a DataFrame

   columns = ["timestamp", "open", "high", "low", "close", "volume"]

   df = pd.DataFrame(ohlcv_list, columns=columns)

   df["timestamp"] = pd.to_datetime(df["timestamp"], unit="s")

   # Return both the DataFrame and metadata

   return df, metadata

Step 2: Creating the OHLCV Chart with mplfinance Library

Now that we have our data in Pandas, we can move on with visualizing it in an OHLCV chart. We’ll use mplfinance, a financial data visualization library to show this data. At the time of writing, you’ll need to use st.pylot to wrap matplotlib figures as discussed in this thread. Our root function will take the dataframe we extracted earlier and fill it with the sorted data (note, this is an important step).

def plot_ohlcv(df):

   # Ensure the DataFrame is sorted by timestamp in ascending order

   df_sorted = df.sort_values("timestamp").set_index("timestamp")

   mpf.plot(

       df_sorted,

       type="candle",

       style="charles",

       title="OHLCV Chart",

       ylabel="Price",

       ylabel_lower="Volume",

       volume=True,

       figratio=(16, 8),

       show_nontrading=False,

   )

Because we labeled our columns with the correct names in the last step, we don’t need to do anything fancy here, other than set up chart attributes to customise its appearance.

Step 3: Chained API Calls to Fetch Network & Trading Pairs Data

Now that we have our core data and plotting functionalities finished, let’s revisit the fetch_ohlcv_data function we created previously. Our function inputs are defined by a network_id, pool_id, and an interval. Because the network and pool ids are both long strings that are unique and specific to a particular network and pool respectively, we would like to abstract the process of selecting and inserting these ids by instead using the names of the respective attributes.

We can achieve this for the user by creating dropdowns that are populated by calls to the associated endpoints. Let’s start by loading all networks with this function: 

@st.cache_data

def fetch_networks_data():

   url = "https://pro-api.coingecko.com/api/v3/onchain/networks?page=1"

   response = requests.get(url, headers=HEADERS)

   if response.status_code == 200:

       networks = response.json()["data"]

       return {network["attributes"]["name"]: network["id"] for network in networks}

   else:

       st.error(

           f"Failed to retrieve networks data. Status code: {response.status_code}"

       )

       return {}

We can now expose those values to the user with a selectbox, where we only display the names of the networks and keep the associated ids abstracted in the background.