How to Build an Akash Network (AKT) Compute Cost Monitor with CoinMarketCap API

Build a compute cost monitor for the Akash network using CoinMarketCap API, AKT token trace, DePIN listing discovery, macro filters, Python examples and production tips.

introduction

Akash Network is a decentralized cloud computing marketplace.

Individual providers and data centers with spare compute capacity list their GPU and CPU resources on Akash. Tenants bid for computation in a reverse auction: the provider willing to accept the lowest price wins the posting. Payment is made via AKT (or USDC via IBC), and is settled on the Akash L1 blockchain (Cosmos SDK chain).

By early 2026, Akash will have over 500 active providers offering GPU compute at 50-80% less than AWS and Azure spot prices. With the growing demand for AI inference, Akash competes directly with Render Network for decentralized GPU compute share.

AKT is the native token of Akash Network. It is used for governance, storage, and as a settlement currency for compute deployments.

Like Celestia (TIA) and Centrifuge (CFG), Akash is a Cosmos SDK L1. AKT trades primarily on CEXs. The CMC DEX API does not index Cosmos chains, all references come from the Core API.

In this guide, you will build Monitor your Akash Network account cost using the CoinMarketCap APIwhere:

• The CoinMarketCap Core API powers the market signals engine
• Akash’s official API and on-chain contracts handle real compute pricing, provider availability and deployment status

Illustration of architecture

The CoinMarketCap API strictly acts as an off-chain signaling layer to monitor AKT token prices, detect DePIN account narrative trend, and filter the overall system. It’s not an oracle for cost calculation, provider monitoring, or a deployment state engine.

Real GPU compute pricing, provider availability, deployment costs, and storage revenues must be validated via the official Akash API or Akash RPC chain.

Why are there no DEX endpoints

AKT is the native token of the Akash L1 blockchain (Cosmos SDK). The CMC DEX API only indexes EVM, Solana, and BNB Chain. AKT trades primarily on CEXs. Use Core API exclusively.

Project preparation

Import operating system
Import time
Import requests

CMC_API_KEY = os.getenv(“CMC_API_KEY”)
CMC_BASE_URL = “https://pro-api.coinmarketcap.com”

vertices = {
“accept”: “application/json”,
“X-CMC_PRO_API_KEY”: CMC_API_KEY,
}

# DePIN Account Sector
account_assets= [“AKT”, “RENDER”, “FIL”, “HNT”]

# DePIN tags for local filtering
DEPIN_TAGS = {“depin”,”Distributed Computing”,”AI Big Data”,”Akash Ecosystem”}

Step 1: Asset map

Map_assets definition(symbols=”AKT, RENDER, FIL, HNT”):
url = f”{CMC_BASE_URL}/v1/cryptocurrency/map”
parameters = {“symbol”:symbols}
r = request.get(url, headers=HEADERS, params=params)
r.raise_for_status()
returns r.json()[“data”]

Definition of Resolve_akt_id(map_data):
For assets in Map_data:
if assets.get(“symbol”) == “AKT” and “akash” in (asset.get(“slug”) or “”).lower():
Return of assets[“id”]
Next return ((a[“id”] to get Map_data if a.get(“symbol”) == “AKT”), None)

AKT is a native currency for Cosmos SDK L1. The platform will be empty and there are no EVM or SPL nodes.

Step 2: Fetch quotes

Uncheck fetch_quotes(ids):
url = f”{CMC_BASE_URL}/v3/cryptocurrency/quotes/latest”
Parameters = {“id”: “,”.join(str(i) for i in ids)}
r = request.get(url, headers=HEADERS, params=params)
r.raise_for_status()
returns r.json()[“data”]

native parse_quote(assets):
usd = next((q for q in assets.get(“quote”, []) if q.get(“symbol”) == “USD”), {})
returns {
“id”: assets.get(“id”),
“symbol”: assets.get(“symbol”),
“Price”: usd.get(“Price”),
“volume_24h”: usd.get(“volume_24h”),
“market_cap”: usd.get(“market_cap”),
“fdv”: usd.get(“full_diluted_market_cap”),
“pct_change_1h”: usd.get(“percent_change_1h”),
“pct_change_24h”: usd.get(“percent_change_24h”),
“pct_change_7d”: usd.get(“percent_change_7d”),
“tvl”: usd.get(“tvl”),
# null for AKT — Cosmos L1
“num_market_pairs”: assets.get(“num_market_pairs”),
}

quotes = {str(a[“id”]): parse_quote(a) for raw_quotes}

Step 3: Record AKT and compare DePIN computing sector

Definition of compute_akt_score (quote):
Result = 0
pct_1h = quote.get(“pct_change_1h”) or 0
pct_24h = quote.get(“pct_change_24h”) or 0
pct_7d = quote.get(“pct_change_7d”) or 0

If pct_24h > 10: result += 30
Elif pct_24h > 5: result += 20
Elif pct_24h > 2: score += 10
elif pct_24h < -15: result -= 25
If pct_7d > 20: result += 20
elif pct_7d > 10: result += 10
If pct_1h > 2: result += 15
elif pct_1h > 0.5: score += 8

Volume = quote.get(“volume_24h”) or 0
If folder > 20_000_000: result += 20
elif folder > 5_000_000: result += 10

mcap = quote.get(“market_cap”) or 0
If mcap > 500_000_000: result += 15
Elif Makab > 100_000_000: result += 8

pairs = quote.get(“num_market_pairs”) or 0
If pairs > 30: score += 8
Elif pairs > 10: score += 4

degree of return

Definition of compare_compute_sector(quotes, asset_IDs):
Comparison = []
For the code in COMPUTE_ASSETS:
assets_id = assets_ids.get(code)
If the asset ID is not:
He continues
q = quotes.get(str(asset_id), {})
compare.append({
“symbol”: symbol,
“market_cap”: q.get(“market_cap”) or 0,
“volume_24h”: q.get(“volume_24h”) or 0,
“pct_change_24h”: q.get(“pct_change_24h”) or 0,
“pct_change_7d”: q.get(“pct_change_7d”) or 0,
})
return sorted(compare, key = lambda x: -x[“pct_change_24h”])

Step 4: Delta Momentum and Macro

Definition of compute_momentum_delta(prev_quote, curr_quote):
prev_price = prev_quote.get(“price”) or 0
curr_price = curr_quote.get(“price”) or 0
if prev_price == 0:
Return nothing
returns {
“price_delta_pct”: ((curr_price – prev_price) / prev_price) * 100,
“vol_delta_pct”: ((curr_quote.get(“volume_24h”) or 0) – (prev_quote.get(“volume_24h”) or 0))
/(prev_quote.get(“volume_24h”) or 1) * 100,
“acceleration”: curr_price > prev_price,
}

def fetch_depin_listings():
url = f”{CMC_BASE_URL}/v3/cryptocurrency/listings/latest”
Parameters = {“sort”: “volume_24h”, “sort_dir”: “desc”, “limit”: 500, “volume_24h_min”: 500_000}
r = request.get(url, headers=HEADERS, params=params)
r.raise_for_status()
returns r.json()[“data”]

Definition of filter_depin_assets(assets):
Results = []
For assets in assets:
tags = array(asset.get(“tags”) or [])
IF tags & DEPIN_TAGS or assets.get(“symbol”) in COMPUTE_ASSETS: results.append(asset)
Return results

def fetch_macro_regime():
fg_url = f”{CMC_BASE_URL}/v3/fear-and-greed/latest”
as_url = f”{CMC_BASE_URL}/v1/altcoin-season-index/latest”
fg = request.get(fg_url, headers=HEADERS).json()[“data”]
tries:
as_idx = request.get(as_url, headers=HEADERS).json()[“data”]
altcoin_index = as_idx.get(“altcoin_index”) or 0
Except for the exception:
altcoin_index = 0 return {“fear_greed_value”: fg.get(“value”), “altcoin_index”: altcoin_index}

Definition of is_regime_favorable(regime):
return (regime.get(“fear_greed_value”) or 0) > 50 and (regime.get(“altcoin_index”) or 0) >= 50

Step 5: Mass Flow

def run_akash_monitor(asset_ids, prev_akt_quote=None):
system = fetch_macro_regime()

Raw_quotes = fetch_quotes(list(asset_ids.values()))
quotes = {str(a[“id”]): parse_quote(a) for raw_quotes}

akt_id = assets_ids.get(“AKT”)
akt_quote = quote.get(str(akt_id), {})

akt_score = compute_akt_score(akt_quote)
If not then it is_regime_favorable(system):
akt_score -= 15

momentum = compute_momentum_delta(prev_akt_quote, akt_quote) if prev_akt_quote else is None
compute_comparison = compute_segment(quotes, assets_ids)

tries:
lists = fetch_depin_listings()
depin_assets = filter_depin_assets(listings)
Except for the exception:
depin_assets = []

depin_trending = [
{“symbol”: a.get(“symbol”), “pct_24h”: (a.get(“quote”) or [{}])[0].get(“percent_change_24h”)}
To get depin_assets[:10]
]

returns {
“akt_signal”: {
“score”: akt_score, “price”: akt_quote.get(“price”),
“pct_24h”: akt_quote.get(“pct_change_24h”), “volume_24h”: akt_quote.get(“volume_24h”),
“momentum”: momentum, “regime_favorable”: is_regime_favorable(regime),
},
“compare_account”: comparison_account,
“depin_trending”: depin_trending,
“System”: the system,
“curr_quote”: akt_quote,
}

Common mistakes

Using DEX endpoints for AKT

AKT is a native currency for Cosmos SDK L1. The CMC DEX API covers only the EVM, Solana, and BNB series. Use Core API exclusively.

AKT is not filtered by alloy

Code=AKT may return multiple entries. Filter by alloy containing ‘akash’.

Citation analysis as a dictation in version 3

The quote is a list. Use the following((q for q in assets.get(“quote”, []) if q.get(“symbol”) == “USD”), {}).

Treat CMC as a computational pricing oracle

CMC tracks market prices, not GPU/CPU compute costs on Akash. Use Akash’s official API to get real algorithmic pricing.

Final thoughts

Key separation:

• CoinMarketCap determines market conditions and DePIN calculates narrative momentum
• Akash’s official API validates real computing prices and provider availability