Hey everyone. If you’ve been trading crypto long enough, you know the harsh reality: technical analysis alone just doesn’t 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 seconds.
I’ve been exploring the Pacifica Exchange 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 events?
So, I spent the weekend building exactly that. I call it the Pacifica Super Scanner. Here’s how I built it and how you can do something similar.
The Architecture: Layer 2 vs. Layer 3
To make this work, I split the bot’s logic into two distinct brains:
Layer 2: The Technical Engine
This is your standard quant stuff. I wrote a Python script that hooks directly into Pacifica’s REST API (`https://api.pacifica.fi/api/v1`). It pulls the top 50 active perpetual markets and downloads the historical klines (candles) for the 1D, 4H, and 1H timeframes.
I wrote custom functions to calculate RSI, EMAs, ATR (for dynamic stop losses), and MACD. The trick here is Multi-Timeframe (MTF) confirmation. A 1H breakout is noise; a 1H breakout backed by a 4H and 1D bullish trend is a high-probability setup.
import sys
import time
import json
import os
import requests
from datetime import datetime
from colorama import init, Fore, Style, Back
# Import Layer 3 Macro Engine
from macro_engine import MacroEngine
# Initialize colorama for Windows terminal
init(autoreset=True)
PACIFICA_API = “https://api.pacifica.fi/api/v1”
TOP_N = 50
def clear_screen():
os.system(‘cls’ if os.name == ‘nt’ else ‘clear’)
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
# ==========================================
# 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)
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
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
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]
def analyze_klines(klines):
if len(klines) < 30:
return {“score”: 0, “rsi”: 50, “trend”: “MIXED”, “macd_bull”: False, “atr”: 0, “signals”: []}
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)
score = 0
sigs = []
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”)
if e20 > e50: score += 1; sigs.append(“EMA20>50”)
else: score -= 1; sigs.append(“EMA20<50”)
if cur > e200: score += 1; sigs.append(“>EMA200”)
else: score -= 1; sigs.append(“<EMA200”)
if mb: score += 1; sigs.append(“MACD Bull”)
else: score -= 1; sigs.append(“MACD Bear”)
if e20 > e50 and cur > e200: trend = “BULLISH”
elif e20 < e50 and cur < e200: trend = “BEARISH”
else: trend = “MIXED”
return {“score”: max(-5, min(5, score)), “rsi”: rsi, “trend”: trend, “macd_bull”: mb, “atr”: atr_v, “signals”: sigs, “price”: cur}
# ==========================================
# 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 []
def get_mtf(symbol):
result = {}
intervals = [(“1d”, 150), (“4h”, 30), (“1h”, 10)]
for tf, days in intervals:
kl = fetch_klines(symbol, tf, days)
result[tf] = analyze_klines(kl)
time.sleep(0.1)
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)
result[“mtf_score”] = round(avg, 1)
result[“triple_confirm”] = “BULL” if all_bull else “BEAR” if all_bear else None
if all_bull: result[“mtf_score”] += 1
if all_bear: result[“mtf_score”] -= 1
return result
# ==========================================
# 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 + “+============================================================+”)
# 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
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”)
def print_signal(coin, macro_data):
score = coin[‘mtf_score’]
# 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
# LAYER 3 MODIFICATION LOGIC
macro_bias = macro_data[‘bias’]
risk_index = macro_data[‘risk_index’]
macro_conf = “Layer 3 Neutral”
conf_color = Fore.YELLOW
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
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
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
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)
reasons = ” + “.join(ta.get(‘signals’, [])[:3])
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 + “+————————————————————+”)
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”)
def main():
clear_screen()
print(Fore.CYAN + “[*] Initializing Layer 3 Macro Engine…”)
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”]}
clear_screen()
print_header(macro_data)
print(Fore.CYAN + “[*] Fetching active markets from Pacifica API…”)
info_req = get(f”{PACIFICA_API}/info”)
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
all_markets = info_req.get(‘data’, [])
symbols = [m[‘symbol’] for m in all_markets if m.get(‘instrument_type’) == ‘perpetual’][:TOP_N]
print(Fore.CYAN + f”[*] Found {len(symbols)} perpetual markets. Analyzing Top {TOP_N}…”)
results = []
total = len(symbols)
for idx, sym in enumerate(symbols):
sys.stdout.write(Fore.WHITE + f”rScanning [{idx+1}/{total}] : {sym:<10}”)
sys.stdout.flush()
mtf_data = get_mtf(sym)
results.append({
“symbol”: sym,
“mtf_score”: mtf_data.get(“mtf_score”, 0),
“data”: mtf_data
})
print(Fore.GREEN + “n[*] Scan Complete! Routing signals through Macro Engine…n”)
results.sort(key=lambda x: abs(x[‘mtf_score’]), reverse=True)
signals_found = 0
for res in results[:10]:
if abs(res[‘mtf_score’]) > 1.5:
print_signal(res, macro_data)
signals_found += 1
if signals_found == 0:
print(Fore.YELLOW + “[-] No strong setups detected across MTF at this time.”)
print(Fore.CYAN + Style.BRIGHT + “>>>” + Fore.WHITE + ” [SCAN FINISHED] ” + Fore.CYAN + Style.BRIGHT + “<<<“)
input(Fore.WHITE + “nPress Enter to exit…”)
if __name__ == “__main__”:
main()
Layer 3: The Macro & Fundamental Engine
This is where things get interesting. I wanted the bot to mimic Pacifica’s “Global Situation” dashboard. I built a standalone `macro_engine.py` that does three things:
1. Live News NLP: It pulls RSS feeds from major crypto news outlets and runs them through `TextBlob` for real-time sentiment analysis.
2. Geopolitical Risk Index: It scans live headlines for trigger words (“war”, “SEC”, “inflation”, “CPI”, “crash”). Based on keyword density, it generates a live Risk Index from 0 to 100.
3. Liquidity Check: It pulls the global Fear & Greed Index to gauge retail liquidity.
import requests
import re
from textblob import TextBlob
from colorama import Fore
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”
]
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
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”
def analyze_global_situation(self):
headlines = self.fetch_rss_headlines()
if not headlines:
headlines = [“Global news feeds currently unavailable.”]
# Sentiment Analysis
pols = [TextBlob(h).sentiment.polarity for h in headlines]
avg_pol = sum(pols) / len(pols) if pols else 0.0
# 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)
# 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
# FNG
fng_val, fng_class = self.get_fng_index()
# 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”
return {
“headlines”: headlines[:3], # Top 3 for display
“sentiment”: avg_pol,
“risk_index”: risk_index,
“fng”: fng_val,
“fng_class”: fng_class,
“bias”: bias
}
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}”)
Bringing It All Together
The magic happens when Layer 2 and Layer 3 talk to each other.
Let’s say Pacifica’s API data shows a massive volume breakout on `$SOL`. The Layer 2 engine flags it as a `STRONG LONG`.
Normally, a basic bot would just execute the trade. But my Super Scanner passes that signal to Layer 3 first.
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 !!!`.
If the macro background is bullish, it upgrades the signal to `+++ L3 ULTRA CONFIRMATION +++`.
The Result
I built the UI directly in the terminal using Python’s `colorama` library because, let’s be honest, nothing feels cooler than a dark terminal spitting out colored quantitative data.
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 — all in about 15 seconds.
If you are building your own tools, here is a piece of advice: Combine your custom API scripts with Pacifica’s native AI tools for maximum alpha. The exchange’s infrastructure is incredibly fast, and their focus on providing macro-level data natively makes it a playground for quants.
I won’t 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 own.
See you on the order books. ✌️
📣 Ready to trade smarter?
app Docs: 👉 Twitter: @pacifica_fi 👉 Discord
Team: @_guynemer @ConstanceWaing @pacifica_intern
P.S First and foremost I’m 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
How I Built a Hedge-Fund Grade Macro Scanner for Pacifica Exchange was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.