{"id":198038,"date":"2026-07-14T15:22:15","date_gmt":"2026-07-14T15:22:15","guid":{"rendered":"https:\/\/mycryptomania.com\/?p=198038"},"modified":"2026-07-14T15:22:15","modified_gmt":"2026-07-14T15:22:15","slug":"how-i-built-a-hedge-fund-grade-macro-scanner-for-pacifica-exchange","status":"publish","type":"post","link":"https:\/\/mycryptomania.com\/?p=198038","title":{"rendered":"How I Built a Hedge-Fund Grade Macro Scanner for Pacifica Exchange"},"content":{"rendered":"

Hey everyone. If you\u2019ve been trading crypto long enough, you know the harsh reality: technical analysis alone just doesn\u2019t cut it anymore. You can have the most beautiful MACD crossover or RSI divergence, but if J-Powell sneezes at a press conference or some geopolitical drama kicks off, your technical setup gets completely invalidated in\u00a0seconds.<\/em><\/p>\n

I\u2019ve been exploring the Pacifica Exchange<\/strong> recently, especially their new global situation and macro tracking dashboards. It got me thinking: what if I could build a custom terminal that inherently correlates technical chart data with real-world macro\u00a0events?<\/p>\n

So, I spent the weekend building exactly that. I call it the Pacifica Super Scanner<\/strong>. Here\u2019s how I built it and how you can do something similar.<\/p>\n

The Architecture: Layer 2 vs. Layer\u00a03<\/h3>\n

To make this work, I split the bot\u2019s logic into two distinct\u00a0brains:<\/p>\n

Layer 2: The Technical Engine<\/strong><\/p>\n

This is your standard quant stuff. I wrote a Python script that hooks directly into Pacifica\u2019s REST API (`https:\/\/api.pacifica.fi\/api\/v1<\/a>`). It pulls the top 50 active perpetual markets and downloads the historical klines (candles) for the 1D, 4H, and 1H timeframes.<\/p>\n

I wrote custom functions to calculate RSI, EMAs, ATR (for dynamic stop losses), and MACD. The trick here is Multi-Timeframe (MTF) confirmation<\/strong>. A 1H breakout is noise; a 1H breakout backed by a 4H and 1D bullish trend is a high-probability setup.<\/p>\n

import sys
import time
import json
import os
import requests
from datetime import datetime
from colorama import init, Fore, Style, Back<\/p>\n

# Import Layer 3 Macro Engine
from macro_engine import MacroEngine<\/p>\n

# Initialize colorama for Windows terminal
init(autoreset=True)<\/p>\n

PACIFICA_API = “https:\/\/api.pacifica.fi\/api\/v1”
TOP_N = 50<\/p>\n

def clear_screen():
os.system(‘cls’ if os.name == ‘nt’ else ‘clear’)<\/p>\n

def get(url, params=None):
try:
r = requests.get(url, params=params, timeout=10)
r.raise_for_status()
return r.json()
except Exception as e:
return None<\/p>\n

# ==========================================
# LAYER 2: TA FUNCTIONS
# ==========================================
def calc_rsi(closes, p=14):
if len(closes) < p + 1: return 50.0
d = [closes[i] – closes[i – 1] for i in range(1, len(closes))]
ag = sum(max(x, 0) for x in d[:p]) \/ p
al = sum(abs(min(x, 0)) for x in d[:p]) \/ p
for x in d[p:]:
ag = (ag * (p – 1) + max(x, 0)) \/ p
al = (al * (p – 1) + abs(min(x, 0))) \/ p
return round(100.0 if al == 0 else 100 – 100 \/ (1 + ag \/ al), 1)<\/p>\n

def calc_ema(prices, p):
if len(prices) < p: return [prices[-1]] if prices else [0]
k = 2 \/ (p + 1)
out = [sum(prices[:p]) \/ p]
for v in prices[p:]:
out.append(v * k + out[-1] * (1 – k))
return out<\/p>\n

def calc_atr(klines, p=14):
if len(klines) < p + 1: return 0.0
trs = []
for i in range(1, len(klines)):
h, l, pc = float(klines[i][‘h’]), float(klines[i][‘l’]), float(klines[i-1][‘c’])
trs.append(max(h – l, abs(h – pc), abs(l – pc)))
avg = sum(trs[:p]) \/ p
for t in trs[p:]:
avg = (avg * (p – 1) + t) \/ p
return avg<\/p>\n

def calc_macd(closes):
if len(closes) < 26: return 0.0, 0.0, False
e12 = calc_ema(closes, 12)
e26 = calc_ema(closes, 26)
diff = len(e12) – len(e26)
ml = [e12[diff + i] – e26[i] for i in range(len(e26))]
sig = calc_ema(ml, 9) if len(ml) >= 9 else [ml[-1]]
return ml[-1], sig[-1], ml[-1] > sig[-1]<\/p>\n

def analyze_klines(klines):
if len(klines) < 30:
return {“score”: 0, “rsi”: 50, “trend”: “MIXED”, “macd_bull”: False, “atr”: 0, “signals”: []}<\/p>\n

closes = [float(k[‘c’]) for k in klines]
cur = closes[-1]
rsi = calc_rsi(closes)
e20 = calc_ema(closes, 20)[-1]
e50 = calc_ema(closes, 50)[-1] if len(closes) >= 50 else e20
e200 = calc_ema(closes, 200)[-1] if len(closes) >= 200 else e20
atr_v = calc_atr(klines)
_, _, mb = calc_macd(closes)<\/p>\n

score = 0
sigs = []<\/p>\n

if rsi < 30: score += 2; sigs.append(“RSI Oversold”)
elif rsi < 45: score += 1; sigs.append(“RSI Buy Zone”)
elif rsi > 70: score -= 2; sigs.append(“RSI Overbought”)
elif rsi > 55: score -= 1; sigs.append(“RSI Weak”)<\/p>\n

if e20 > e50: score += 1; sigs.append(“EMA20>50”)
else: score -= 1; sigs.append(“EMA20<50”)<\/p>\n

if cur > e200: score += 1; sigs.append(“>EMA200”)
else: score -= 1; sigs.append(“<EMA200”)<\/p>\n

if mb: score += 1; sigs.append(“MACD Bull”)
else: score -= 1; sigs.append(“MACD Bear”)<\/p>\n

if e20 > e50 and cur > e200: trend = “BULLISH”
elif e20 < e50 and cur < e200: trend = “BEARISH”
else: trend = “MIXED”<\/p>\n

return {“score”: max(-5, min(5, score)), “rsi”: rsi, “trend”: trend, “macd_bull”: mb, “atr”: atr_v, “signals”: sigs, “price”: cur}<\/p>\n

# ==========================================
# DATA COLLECTION
# ==========================================
def fetch_klines(symbol, interval, lookback_days):
start_time = int((time.time() – (86400 * lookback_days)) * 1000)
data = get(f”{PACIFICA_API}\/kline”, {“symbol”: symbol, “interval”: interval, “start_time”: start_time})
if data and data.get(‘success’) and ‘data’ in data:
return data[‘data’]
return []<\/p>\n

def get_mtf(symbol):
result = {}
intervals = [(“1d”, 150), (“4h”, 30), (“1h”, 10)] <\/p>\n

for tf, days in intervals:
kl = fetch_klines(symbol, tf, days)
result[tf] = analyze_klines(kl)
time.sleep(0.1) <\/p>\n

scores = [result[tf][“score”] for tf in [“1d”, “4h”, “1h”] if result[tf]]
avg = sum(scores) \/ len(scores) if scores else 0
all_bull = len(scores) == 3 and all(s > 0 for s in scores)
all_bear = len(scores) == 3 and all(s < 0 for s in scores)<\/p>\n

result[“mtf_score”] = round(avg, 1)
result[“triple_confirm”] = “BULL” if all_bull else “BEAR” if all_bear else None<\/p>\n

if all_bull: result[“mtf_score”] += 1
if all_bear: result[“mtf_score”] -= 1<\/p>\n

return result<\/p>\n

# ==========================================
# UI & VISUALIZATION
# ==========================================
def print_header(macro_data):
print(Fore.CYAN + Style.BRIGHT + “+============================================================+”)
print(Fore.CYAN + Style.BRIGHT + “|” + Fore.WHITE + ” PACIFICA SUPER SCANNER : ACTIVE ” + Fore.CYAN + Style.BRIGHT + “|”)
print(Fore.CYAN + Style.BRIGHT + “|” + Fore.CYAN + ” [ Multi-Timeframe Algorithmic Analysis ] ” + Fore.CYAN + Style.BRIGHT + “|”)
print(Fore.CYAN + Style.BRIGHT + “+============================================================+”)<\/p>\n

# LAYER 3 UI BLOCK
bias_color = Fore.GREEN if macro_data[‘bias’] == ‘BULLISH’ else Fore.RED if macro_data[‘bias’] == ‘BEARISH’ else Fore.YELLOW
risk_color = Fore.RED if macro_data[‘risk_index’] > 60 else Fore.YELLOW if macro_data[‘risk_index’] > 40 else Fore.GREEN<\/p>\n

print(Fore.MAGENTA + Style.BRIGHT + “| [LAYER 3] GLOBAL SITUATION & MACRO ENGINE |”)
print(Fore.MAGENTA + “+————————————————————+”)
print(Fore.MAGENTA + “| ” + Fore.WHITE + f”Global Bias : ” + bias_color + Style.BRIGHT + f”{macro_data[‘bias’]:<43}” + Fore.MAGENTA + “|”)
print(Fore.MAGENTA + “| ” + Fore.WHITE + f”Risk Index : ” + risk_color + f”{macro_data[‘risk_index’]}\/100″ + ” ” * (39 – len(str(macro_data[‘risk_index’]))) + Fore.MAGENTA + “|”)
print(Fore.MAGENTA + “| ” + Fore.WHITE + f”Fear & Greed : ” + Fore.YELLOW + f”{macro_data[‘fng’]} ({macro_data[‘fng_class’]})” + ” ” * (33 – len(str(macro_data[‘fng’])) – len(macro_data[‘fng_class’])) + Fore.MAGENTA + “|”)
print(Fore.MAGENTA + “| ” + Fore.WHITE + f”Live Headlines:” + ” ” * 43 + Fore.MAGENTA + “|”)
for i, h in enumerate(macro_data[‘headlines’][:2]): # Show top 2
text = (h[:54] + ‘..’) if len(h) > 54 else h
print(Fore.MAGENTA + “| ” + Fore.WHITE + f” > {text:<54}” + Fore.MAGENTA + “|”)
print(Fore.MAGENTA + “+============================================================+n”)<\/p>\n

def print_signal(coin, macro_data):
score = coin[‘mtf_score’]<\/p>\n

# Layer 2 Technical Direction
if score > 1.5: direction = “LONG”; color = Fore.GREEN; bg = Back.GREEN
elif score < -1.5: direction = “SHORT”; color = Fore.RED; bg = Back.RED
else: return <\/p>\n

# LAYER 3 MODIFICATION LOGIC
macro_bias = macro_data[‘bias’]
risk_index = macro_data[‘risk_index’]<\/p>\n

macro_conf = “Layer 3 Neutral”
conf_color = Fore.YELLOW<\/p>\n

if direction == “LONG”:
if macro_bias == “BULLISH” and risk_index < 50:
macro_conf = “+++ L3 ULTRA CONFIRMATION +++”
conf_color = Fore.GREEN
bg = Back.GREEN + Style.BRIGHT
elif macro_bias == “BEARISH” or risk_index > 65:
macro_conf = “!!! L3 MACRO DANGER: REDUCE RISK !!!”
conf_color = Fore.RED
bg = Back.YELLOW + Fore.BLACK # Warning state<\/p>\n

elif direction == “SHORT”:
if macro_bias == “BEARISH”:
macro_conf = “+++ L3 ULTRA CONFIRMATION +++”
conf_color = Fore.GREEN
elif macro_bias == “BULLISH”:
macro_conf = “!!! L3 MACRO DANGER: AVOID SHORT !!!”
conf_color = Fore.RED
bg = Back.YELLOW + Fore.BLACK<\/p>\n

ta = coin[‘data’].get(“1d”, {})
price = ta.get(‘price’, 0)
atr = ta.get(‘atr’, price * 0.02) if ta.get(‘atr’) else price * 0.02<\/p>\n

sl = price – (atr * 1.5) if direction == “LONG” else price + (atr * 1.5)
tp = price + (atr * 3.0) if direction == “LONG” else price – (atr * 3.0)<\/p>\n

reasons = ” + “.join(ta.get(‘signals’, [])[:3])<\/p>\n

print(Fore.CYAN + “+————————————————————+”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”TARGET ASSET: {coin[‘symbol’]:<45}” + Fore.CYAN + “|”)
print(Fore.CYAN + “+————————————————————+”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”Current Price : ” + Fore.YELLOW + f”${price:<41.4f}” + Fore.CYAN + “|”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”MTF Score : ” + color + f”{score:<41}” + Fore.CYAN + “|”)
print(Fore.CYAN + “+————————————————————+”)<\/p>\n

signal_box = bg + f” {direction} ” + Style.RESET_ALL
print(Fore.CYAN + “| ” + Fore.WHITE + f”SIGNAL : {signal_box:<53}” + Fore.CYAN + “|”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”TA REASON : {reasons:<53}” + Fore.CYAN + “|”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”MACRO FILTER : {conf_color}{macro_conf:<53}” + Fore.CYAN + “|”)
print(Fore.CYAN + “+————————————————————+”)
print(Fore.CYAN + “| ” + Fore.WHITE + f”SUGGESTED SL : ” + Fore.MAGENTA + f”${sl:<19.4f} ” + Fore.WHITE + f”TP : ” + Fore.GREEN + f”${tp:<16.4f}” + Fore.CYAN + “|”)
print(Fore.CYAN + “+————————————————————+n”)<\/p>\n

def main():
clear_screen()
print(Fore.CYAN + “[*] Initializing Layer 3 Macro Engine…”)<\/p>\n

try:
macro = MacroEngine()
macro_data = macro.analyze_global_situation()
except Exception as e:
print(Fore.RED + f”[-] Macro Engine offline: {e}. Defaulting to Neutral.”)
macro_data = {“bias”: “NEUTRAL”, “risk_index”: 50, “fng”: 50, “fng_class”: “Neutral”, “headlines”: [“Offline”]}<\/p>\n

clear_screen()
print_header(macro_data)<\/p>\n

print(Fore.CYAN + “[*] Fetching active markets from Pacifica API…”)
info_req = get(f”{PACIFICA_API}\/info”)<\/p>\n

if not info_req or not info_req.get(‘success’):
print(Fore.RED + “[ERROR] Failed to connect to Pacifica API.”)
input(“nPress Enter to exit…”)
return<\/p>\n

all_markets = info_req.get(‘data’, [])
symbols = [m[‘symbol’] for m in all_markets if m.get(‘instrument_type’) == ‘perpetual’][:TOP_N]<\/p>\n

print(Fore.CYAN + f”[*] Found {len(symbols)} perpetual markets. Analyzing Top {TOP_N}…”)<\/p>\n

results = []
total = len(symbols)<\/p>\n

for idx, sym in enumerate(symbols):
sys.stdout.write(Fore.WHITE + f”rScanning [{idx+1}\/{total}] : {sym:<10}”)
sys.stdout.flush()<\/p>\n

mtf_data = get_mtf(sym)
results.append({
“symbol”: sym,
“mtf_score”: mtf_data.get(“mtf_score”, 0),
“data”: mtf_data
})<\/p>\n

print(Fore.GREEN + “n[*] Scan Complete! Routing signals through Macro Engine…n”)<\/p>\n

results.sort(key=lambda x: abs(x[‘mtf_score’]), reverse=True)<\/p>\n

signals_found = 0
for res in results[:10]:
if abs(res[‘mtf_score’]) > 1.5:
print_signal(res, macro_data)
signals_found += 1<\/p>\n

if signals_found == 0:
print(Fore.YELLOW + “[-] No strong setups detected across MTF at this time.”)<\/p>\n

print(Fore.CYAN + Style.BRIGHT + “>>>” + Fore.WHITE + ” [SCAN FINISHED] ” + Fore.CYAN + Style.BRIGHT + “<<<“)
input(Fore.WHITE + “nPress Enter to exit…”)<\/p>\n

if __name__ == “__main__”:
main()<\/p>\n

Layer 3: The Macro & Fundamental Engine<\/strong><\/h3>\n

This is where things get interesting. I wanted the bot to mimic Pacifica\u2019s \u201cGlobal Situation\u201d dashboard. I built a standalone `macro_engine.py` that does three\u00a0things:<\/p>\n

1. Live News NLP:<\/strong> It pulls RSS feeds from major crypto news outlets and runs them through `TextBlob` for real-time sentiment analysis.<\/p>\n

2. Geopolitical Risk Index:<\/strong> It scans live headlines for trigger words (\u201cwar\u201d, \u201cSEC\u201d, \u201cinflation\u201d, \u201cCPI\u201d, \u201ccrash\u201d). Based on keyword density, it generates a live Risk Index from 0 to\u00a0100.<\/p>\n

3. Liquidity Check:<\/strong> It pulls the global Fear & Greed Index to gauge retail liquidity.<\/p>\n

import requests
import re
from textblob import TextBlob
from colorama import Fore<\/p>\n

class MacroEngine:
def __init__(self):
self.news_sources = [
“https:\/\/cointelegraph.com\/rss”,
“https:\/\/decrypt.co\/feed”
]
self.risk_keywords = [
“war”, “conflict”, “strike”, “nuclear”, “hack”, “ban”, “lawsuit”,
“fed”, “rate”, “inflation”, “cpi”, “crash”, “sec”, “investigation”
]
self.bull_keywords = [
“etf”, “inflow”, “adoption”, “approval”, “surge”, “breakout”,
“bull”, “mint”, “reserves”
]<\/p>\n

def fetch_rss_headlines(self):
headlines = []
for url in self.news_sources:
try:
r = requests.get(url, headers={“User-Agent”: “Mozilla\/5.0”}, timeout=5)
if r.status_code == 200:
txt = r.text
t = re.findall(r”<title><![CDATA[(.*?)]]><\/title>”, txt)
if not t:
t = re.findall(r”<title>(.*?)<\/title>”, txt, re.DOTALL)
headlines.extend([x.strip() for x in t[1:10]]) # Skip main title, get 9 items
except:
pass
return headlines<\/p>\n

def get_fng_index(self):
try:
r = requests.get(“https:\/\/api.alternative.me\/fng\/?limit=1”, timeout=5)
if r.status_code == 200:
data = r.json().get(“data”, [])
if data:
return int(data[0][“value”]), data[0][“value_classification”]
except:
pass
return 50, “Neutral”<\/p>\n

def analyze_global_situation(self):
headlines = self.fetch_rss_headlines()
if not headlines:
headlines = [“Global news feeds currently unavailable.”]<\/p>\n

# Sentiment Analysis
pols = [TextBlob(h).sentiment.polarity for h in headlines]
avg_pol = sum(pols) \/ len(pols) if pols else 0.0<\/p>\n

# Keyword Risk Analysis
all_text = ” “.join(headlines).lower()
risk_hits = sum(1 for w in self.risk_keywords if w in all_text)
bull_hits = sum(1 for w in self.bull_keywords if w in all_text)<\/p>\n

# Calculate Global Risk Index (0-100)
base_risk = 30 # Default baseline
risk_index = min(100, base_risk + (risk_hits * 15) – (bull_hits * 5))
risk_index = max(0, risk_index) # Floor at 0<\/p>\n

# FNG
fng_val, fng_class = self.get_fng_index()<\/p>\n

# Determine Overall Macro Bias
bias = “NEUTRAL”
if avg_pol > 0.15 and fng_val > 55 and risk_index < 50:
bias = “BULLISH”
elif avg_pol < -0.1 or risk_index > 75 or fng_val < 40:
bias = “BEARISH”<\/p>\n

return {
“headlines”: headlines[:3], # Top 3 for display
“sentiment”: avg_pol,
“risk_index”: risk_index,
“fng”: fng_val,
“fng_class”: fng_class,
“bias”: bias
}<\/p>\n

if __name__ == “__main__”:
engine = MacroEngine()
res = engine.analyze_global_situation()
print(“— PACIFICA GLOBAL SITUATION —“)
print(f”Bias: {res[‘bias’]}”)
print(f”Risk Index: {res[‘risk_index’]}\/100″)
print(f”Fear\/Greed: {res[‘fng’]} ({res[‘fng_class’]})”)
print(f”Sentiment: {res[‘sentiment’]:.2f}”)
print(“Top News:”)
for h in res[‘headlines’]:
print(f” – {h}”)<\/p>\n

Bringing It All\u00a0Together<\/h3>\n

The magic happens when Layer 2 and Layer 3 talk to each\u00a0other.<\/p>\n

Let\u2019s say Pacifica\u2019s API data shows a massive volume breakout on `$SOL`. The Layer 2 engine flags it as a `STRONG\u00a0LONG`.<\/p>\n

Normally, a basic bot would just execute the trade. But my Super Scanner passes that signal to Layer 3\u00a0first.<\/p>\n

If Layer 3 detects a high Risk Index (e.g., bad inflation data just dropped), it slaps a warning on the trade: `!!! L3 MACRO DANGER: REDUCE RISK\u00a0!!!`.<\/p>\n

If the macro background is bullish, it upgrades the signal to `+++ L3 ULTRA CONFIRMATION +++`.<\/p>\n

The Result<\/strong><\/p>\n

I built the UI directly in the terminal using Python\u2019s `colorama` library because, let\u2019s be honest, nothing feels cooler than a dark terminal spitting out colored quantitative data.<\/p>\n

It scans 50 coins, cross-references them with global geopolitical risk, calculates dynamic Stop Losses and Take Profits based on ATR, and prints the top 10 best setups\u200a\u2014\u200aall in about 15\u00a0seconds.<\/p>\n

If you are building your own tools, here is a piece of advice: Combine your custom API scripts with Pacifica\u2019s native AI tools for maximum alpha.<\/strong> The exchange\u2019s infrastructure is incredibly fast, and their focus on providing macro-level data natively makes it a playground for\u00a0quants.<\/p>\n

I won\u2019t be dropping the full source code just yet (a man has to protect his edge, right?), but the logic is there for you to build your\u00a0own.<\/p>\n

See you on the order books.\u00a0\u270c\ufe0f<\/p>\n

\ud83d\udce3 Ready to trade smarter?
app<\/a> Docs:<\/a> \ud83d\udc49 Twitter: @pacifica_fi<\/a> \ud83d\udc49 Discord<\/a>
Team: @_guynemer<\/a> @ConstanceWaing<\/a> @pacifica_intern<\/a><\/p>\n

P.S First and foremost I\u2019m obligated to disclose that none of this is investment advice, everything I state in this article are my opinions only and actions that I personally take in hopes of achieving certain results. Investments in cryptocurrencies are risky and results are not guarantee<\/em><\/p>\n

How I Built a Hedge-Fund Grade Macro Scanner for Pacifica Exchange<\/a> was originally published in Coinmonks<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>","protected":false},"excerpt":{"rendered":"

Hey everyone. If you\u2019ve been trading crypto long enough, you know the harsh reality: technical analysis alone just doesn\u2019t cut it anymore. You can have the most beautiful MACD crossover or RSI divergence, but if J-Powell sneezes at a press conference or some geopolitical drama kicks off, your technical setup gets completely invalidated in\u00a0seconds. I\u2019ve […]<\/p>\n","protected":false},"author":0,"featured_media":198039,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-198038","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/198038"}],"collection":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=198038"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/198038\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/media\/198039"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=198038"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=198038"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=198038"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}