Altcoins are cryptocurrencies other than Bitcoin, which share some similar characteristics as Bitcoin but may differ in their mechanism to produce blocks or validate transactions. It improves on aspects of Bitcoin, offers high potential rewards, but does not have Bitcoin’s market share, and is significantly riskier as many altcoins end up failing. There are over 16000 coins as of December 2021.
This article will take us through the top-down approach of finding the altcoin gems as outlined by Guy in this video, and automating the process wherever possible using Python.
Low market cap coins have a higher potential to jump in price. First, let’s filter out the cryptocurrency list with a market cap between 5Mn and 10Mn. This is not a hard cutoff, but 10Mn as the upper bound gives enough room for the coin to grow, and 5Mn as the lower bound weeds out many of the ‘sh*t’ coins. But feel free to play around with the bounds.
Install the required packages
from requests import Request, Session
from requests.exceptions import ConnectionError, Timeout, TooManyRedirects
import json
import pandas as pdSign up for a developer portal account on CoinMarketCap and you would be provided with an API key. Copy the API key and paste it into the code below. The below snippet is to make an API call to CoinMarketCap to download the top 5000 cryptocurrencies based on Market Cap and convert the list into a pandas data frame.
url = 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/listings/latest'
parameters = {
'start':'1',
'limit':'5000',
'convert':'USD'
}
headers = {
'Accepts': 'application/json',
'X-CMC_PRO_API_KEY': 'PASTE_YOUR_API_KEY_HERE',
}session = Session()
session.headers.update(headers)try:
response = session.get(url, params=parameters)
data = json.loads(response.text)
print(data)
except (ConnectionError, Timeout, TooManyRedirects) as e:
print(e)coindf = pd.json_normalize(data['data'])
Filtering the dataset based on Market Cap.
coindf2 = coindf[ (coindf['quote.USD.market_cap'] < 10000000) & (coindf['quote.USD.market_cap'] > 5000000)]Filtering on Market Cap leaves us with only 221 Cryptocurrencies out of the 5000 we started with. The dataset (not all rows and columns shown) looks as below ->
The 24 hr volume gives us a sense of how active the trading is, i.e ‘Is the coin in use?. Let’s filter out the list by keeping only the coins with the Volume to Market Cap ratio between 10% and 50%. This means the coin would take approximately 2 to 10 days to cover its market cap.
coindf3 = coindf2[ (coindf2['quote.USD.volume_24h']/coindf2['quote.USD.market_cap']).between(0.1,0.5) ]This leaves us with just 41 coins to look at. Now we need to investigate whether the volume of these coins contains any wash trading. Wash trading is when the investor simultaneously sells and buys the same security to artificially increase the trading volume, giving the impression the security is more in demand than it really is.
Many of the unregulated exchanges engage in wash trading to inflate their trading volume. Coingecko has developed a “Trust Score” for exchanges based on liquidity, the scale of operations, security, etc. A green signal tells us that the exchange is trustworthy. For example, shown below is the exchange listings for the cryptocurrency: “Lympo”
Instead of manually checking the exchange listings for each of the coins on the website, we can download this data using the Coingecko API. Also, let’s keep only the coins where the trading volume through the “green” exchanges is the majority.
from pycoingecko import CoinGeckoAPI
cg = CoinGeckoAPI()crypto_list_shortlisted = []for index, row in coindf3.iterrows():
symbol1 = row.symbol.lower()
symbol2 = coindf3.loc[index]['name'].lower()try:
if df.groupby('trust_score')['volume'].sum()['green']/df.groupby('trust_score')['volume'].sum().sum() >= 0.5:
print(symbol1)
coin_exchange = cg.get_coin_by_id(id = symbol1 )['tickers']
df = pd.DataFrame(coin_exchange)
df.trust_score.value_counts()
except:
print(symbol2)
try:
coin_exchange = cg.get_coin_by_id(id = symbol2 )['tickers']
except:
continue
df = pd.DataFrame(coin_exchange)
df.trust_score.value_counts()
crypto_list_shortlisted.append(symbol1)
Starting with 5000 coins, we are left with only 14 coins to research :
On-chain analytics is the data that can be extracted from a blockchain. A website to get on-chain metrics is https://www.intotheblock.com. The few metrics to look at are:
- % Active Addresses (Addresses with activity/Total number of Addresses with balance): A higher ratio is better as it signifies a more active network
2. Comparison of Active Addresses to New Addresses: If the ratio above remains constant over time, take a look at the count of active vs new addresses separately and if they are moving together.
3. Distribution of tokens on the network: Tokens concentrated in a few addresses is not desirable as they can easily control the market
Check the GitHub repository of the token, and check the “insights” section to observe the frequency of code commits. Also, check the activity on the issues section. Example for MATIC token shown below :
Some of the development may not be reflected in the Github repository, so be sure to also check out the official webpage of the token. As an example, the webpage of MATIC token -> https://blog.polygon.technology
Last but not the least, we need to check the qualitative aspects of the project :
- Do a background of the team’s credentials and experiences (LinkedIn, Twitter, and other Social Media).
- READ the white paper: Read about the tech (consensus protocol, interoperability, scalability), use cases, and roadmap of the project
- Community: Check the activity/discussions of the token’s owners and followers. The social media stats can be found here -> https://www.intotheblock.com
References :
