📈 Top 25 Crypto
Loading prices…
Trade on Hyperliquid →Join HL → Data: CoinGecko
How I Scan Every Hyperliquid Perp Each Morning With Python
Python · Hyperliquid API · Screening

How I Scan Every Hyperliquid Perp
Each Morning With Python

📅 November 2026 ⏱ 13 min read 🐍 Tools & Code
There are well over a hundred perps on Hyperliquid. Nobody can flip through all of them before coffee. A free API and under 150 lines of Python can: one scan, two minutes, and a short watchlist of the markets that are actually moving, with crowded funding flagged.
THE MORNING SCAN · ALL PERPS → FILTER → RANK → WATCHLIST (ILLUSTRATIVE) 1 · PULL metaAndAssetCtxs price · volume · OI funding (every perp) ALL → 2 · FILTER 24h volume > $1M skip delisted + 30 daily candles LIQUID → 3 · RANK 7-day momentum (70%) turnover (30%) trend vs 20-day SMA SCORED → 4 · WATCHLIST ▲ top 10 long ideas ▼ top 10 short ideas ⚠ crowded funding ~20
⚠️ Educational content only. The script produces a watchlist, not trade signals. Nothing in it is a recommendation to buy or sell anything. Sample output in this post is hypothetical. Always run your own chart analysis and use a stop.
Every morning I used to open the Hyperliquid app and click through markets until something “looked good.” That meant I mostly checked the same ten coins, missed whatever was quietly trending elsewhere, and let my mood pick the trade. A scanner fixes all three: it looks at every perp, measures the same things the same way each day, and hands me a short list to analyze properly.
This post walks through exactly how it works: the free Hyperliquid API it uses, the five numbers it calculates, the full Python script you can copy, how to read the output, and the 15-minute routine that turns the list into trade plans. You don’t need to be a programmer; if you can install Python and copy a file, you can run it. New to the platform? Start with The Ultimate Guide to Hyperliquid DEX.

What the Scan Has to Answer

A screener is only useful if it answers specific questions. Mine answers three:
📊 1 · Where is the money actually trading?
Thin markets have wide spreads, jumpy wicks and sweeps that eat stops. The scan drops anything with less than $1M in 24-hour volume before doing anything else.
📈 2 · What is trending, and which way?
Seven-day momentum plus where price sits against its 20-day average. Up and above the average goes on the long list; down and below goes on the short list. Same idea as the regime checklist, run on every market at once.
⚠️ 3 · Where is the crowd already leaning?
Extreme funding means one side is paying heavily to hold. Those markets are flagged, and a long idea with crowded long funding is kept off the list, because that’s where sharp flushes tend to start.

The Data: Two Free API Calls

Hyperliquid has a public Info API at https://api.hyperliquid.xyz/info. No account, no API key, no wallet connection: you send a small JSON request and get data back. The scan uses two request types.
What each request returns
metaAndAssetCtxsOne call, every perp. Market names plus a live context for each: markPx (price), prevDayPx (price 24 hours ago), dayNtlVlm (24h volume in dollars), openInterest (in coins) and funding (the current hourly rate).
candleSnapshotCandles for one market and interval. The scan asks for 30 daily candles per market to measure the 7-day move and the 20-day average.
Be polite to the API. Hyperliquid’s docs set a shared limit of 1,200 request “weight” per minute per IP, and most info requests (including candles) weigh at least 20. That’s why the script pauses 1.5 seconds between candle requests. A full scan takes a couple of minutes and stays comfortably under the limit.

The 5 Numbers It Calculates

Metric · formula · why it matters
24h volumedayNtlVlmThe liquidity filter. Under $1M, skip it.
7-day momentumclose ÷ close 7 days ago − 1The main ranking factor. Long enough to ignore one noisy day, short enough to stay current.
vs 20-day SMAclose ÷ SMA20 − 1A trend filter. Longs must be above it, shorts below. See Moving Averages.
Turnover24h volume ÷ OI in $How actively positions are changing hands. High turnover means attention is on this market right now. More on open interest.
Funding APRhourly rate × 24 × 365Turns the tiny hourly number into something readable. Above about ±50% a year, the script calls it crowded.
Each market then gets a score: 70% from its momentum rank and 30% from its turnover rank, both scaled 0 to 1 across all scanned markets. The long list takes the highest scores that are trending up with non-crowded funding; the short list mirrors it. Ranking against the other markets, rather than using fixed thresholds, means the scan adapts automatically to quiet and wild weeks.

Setup: 5 Minutes, One Time

1
Install Python 3 from python.org. On Windows, tick “Add Python to PATH” during install.
2
Install the one library it needs. Open Command Prompt (Windows) or Terminal (Mac) and run pip install requests.
3
Save the script. Copy the code below into a plain-text file named hl_morning_scan.py, for example in your Downloads folder.
4
Run it. In Command Prompt or Terminal, go to that folder (cd Downloads) and type python hl_morning_scan.py.
5
Read the results. The top lists print on screen, and the full ranked table saves next to the script as a dated CSV you can open in Excel or Google Sheets.
It only reads public data. The script never asks for a private key, seed phrase or wallet, and it can’t place orders. If any “scanner” you download asks for your private key, don’t run it.

The Full Script

About 140 lines, heavily commented. The settings at the top are the parts you’ll want to tweak: the volume filter, what counts as crowded funding, and how many ideas to print. Scroll the box sideways on mobile.
hl_morning_scan.py
Python 3 · requires: requests
"""
hl_morning_scan.py - scan every Hyperliquid perp and rank long/short watchlist candidates.

Educational example from rchrisford.com. Not financial advice. The output is a
watchlist to research, not a list of trades.

Requires: Python 3.9+ and the requests library  (pip install requests)
Run:      python hl_morning_scan.py
"""

import csv
import time
from datetime import datetime, timezone

import requests

API = "https://api.hyperliquid.xyz/info"
MIN_VOLUME_USD = 1_000_000   # skip markets with under $1M of 24h volume
CROWDED_FUNDING_APR = 50.0   # annualized funding (%) we treat as "crowded"
TOP_N = 10                   # how many longs / shorts to print
PAUSE_SECONDS = 1.5          # spacing between candle requests (stays well under rate limits)


def post(body):
    r = requests.post(API, json=body, timeout=20)
    r.raise_for_status()
    return r.json()


def load_markets():
    """One call returns every perp: metadata + live context (price, volume, OI, funding)."""
    meta, ctxs = post({"type": "metaAndAssetCtxs"})
    markets = []
    for asset, ctx in zip(meta["universe"], ctxs):
        if asset.get("isDelisted"):
            continue
        mark = float(ctx.get("markPx") or 0)
        prev = float(ctx.get("prevDayPx") or 0)
        if mark <= 0 or prev <= 0:
            continue
        oi_usd = float(ctx["openInterest"]) * mark
        vol_usd = float(ctx["dayNtlVlm"])
        funding_hr = float(ctx["funding"])            # current hourly funding rate
        markets.append({
            "coin": asset["name"],
            "price": mark,
            "chg_24h_pct": (mark / prev - 1) * 100,
            "volume_24h": vol_usd,
            "oi_usd": oi_usd,
            "turnover": vol_usd / oi_usd if oi_usd else 0.0,
            "funding_apr_pct": funding_hr * 24 * 365 * 100,
        })
    return markets


def daily_closes(coin, days=30):
    """Daily closing prices for the last `days` days."""
    end = int(time.time() * 1000)
    start = end - days * 86_400_000
    candles = post({"type": "candleSnapshot",
                    "req": {"coin": coin, "interval": "1d",
                            "startTime": start, "endTime": end}})
    return [float(c["c"]) for c in candles]


def add_trend(m):
    closes = daily_closes(m["coin"])
    if len(closes) < 21:
        m["chg_7d_pct"], m["vs_sma20_pct"] = None, None
        return
    sma20 = sum(closes[-20:]) / 20
    m["chg_7d_pct"] = (closes[-1] / closes[-8] - 1) * 100
    m["vs_sma20_pct"] = (closes[-1] / sma20 - 1) * 100


def rank(values, reverse=False):
    """Percentile rank 0-1 for each value (1 = best)."""
    order = sorted(range(len(values)), key=lambda i: values[i], reverse=reverse)
    out = [0.0] * len(values)
    for pos, i in enumerate(order):
        out[i] = pos / max(len(values) - 1, 1)
    return out


def main():
    markets = [m for m in load_markets() if m["volume_24h"] >= MIN_VOLUME_USD]
    print(f"{len(markets)} perps with 24h volume >= ${MIN_VOLUME_USD:,.0f}. Fetching daily candles...")

    for i, m in enumerate(markets, 1):
        try:
            add_trend(m)
        except requests.RequestException as e:
            print(f"  skipped {m['coin']}: {e}")
            m["chg_7d_pct"], m["vs_sma20_pct"] = None, None
        if i % 10 == 0:
            print(f"  {i}/{len(markets)}")
        time.sleep(PAUSE_SECONDS)

    markets = [m for m in markets if m["chg_7d_pct"] is not None]
    mom = rank([m["chg_7d_pct"] for m in markets])
    trn = rank([m["turnover"] for m in markets])
    for m, a, b in zip(markets, mom, trn):
        m["score"] = round(0.7 * a + 0.3 * b, 3)        # long score: strong momentum + active market
        m["short_score"] = round(0.7 * (1 - a) + 0.3 * b, 3)  # short score: weak momentum + active market
        m["crowded"] = abs(m["funding_apr_pct"]) >= CROWDED_FUNDING_APR

    longs = sorted((m for m in markets if m["chg_7d_pct"] > 0 and m["vs_sma20_pct"] > 0
                    and m["funding_apr_pct"] < CROWDED_FUNDING_APR),
                   key=lambda m: m["score"], reverse=True)[:TOP_N]
    shorts = sorted((m for m in markets if m["chg_7d_pct"] < 0 and m["vs_sma20_pct"] < 0
                     and m["funding_apr_pct"] > -CROWDED_FUNDING_APR),
                    key=lambda m: m["short_score"], reverse=True)[:TOP_N]

    def show(title, rows):
        print(f"\n{title}")
        print(f"{'COIN':<10}{'7D %':>8}{'vs SMA20':>10}{'24H VOL':>14}{'TURN':>9}{'FUND APR':>10}")
        for m in rows:
            print(f"{m['coin']:<10}{m['chg_7d_pct']:>8.1f}{m['vs_sma20_pct']:>10.1f}"
                  f"{m['volume_24h']:>14,.0f}{m['turnover']:>9.2f}{m['funding_apr_pct']:>10.1f}")

    show("LONG WATCHLIST (uptrend, funding not crowded)", longs)
    show("SHORT WATCHLIST (downtrend, funding not crowded)", shorts)

    crowded = [m["coin"] for m in markets if m["crowded"]]
    print("\nCROWDED FUNDING (careful either way):", ", ".join(crowded) or "none")

    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    path = f"hl_scan_{stamp}.csv"
    fields = ["coin", "price", "chg_24h_pct", "chg_7d_pct", "vs_sma20_pct", "volume_24h",
              "oi_usd", "turnover", "funding_apr_pct", "score", "short_score", "crowded"]
    with open(path, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
        w.writeheader()
        w.writerows(sorted(markets, key=lambda m: m["score"], reverse=True))
    print(f"\nFull results saved to {path}")


if __name__ == "__main__":
    main()

Reading the Output

Here’s what the long list looks like on screen. The tickers and numbers below are made up to show the format, not a real scan.
Hypothetical long watchlist output
COIN7D %vs SMA2024H VOLTURNFUND APR
AAA18.412.184,200,0003.1014.2
BBB11.78.622,500,0004.859.6
CCC9.25.36,900,0001.9541.8
How I’d read it: AAA is the cleanest name: strong 7-day move, well above its average, deep volume, normal funding. BBB is smaller but heavily traded relative to its open interest, so attention is building. CCC passes the filters, but funding is creeping toward the crowded zone, so I’d want a pullback rather than a chase. Then there’s the “crowded funding” line at the bottom of the output: those markets aren’t trades on their own, but they’re where squeezes in either direction are most likely.
💡 The List Is the Start, Not the Trade
A high score means “worth looking at,” never “buy now.” The strongest 7-day movers are often extended. The scan finds where to look; the chart decides whether and where to enter.

My 15-Minute Morning Routine

1
Run the scan (2 minutes). Coffee while it fetches.
2
Pick 3 to 5 names from the two lists. Skip anything in the crowded-funding line unless the setup is exceptional.
3
Top-down each one using multi-timeframe analysis: map, setup, trigger.
4
Mark the level and set an alert. A pullback to support, the 20 SMA or a Fib zone. If price never gets there, there’s no trade.
5
Fill in the checklist when an alert fires: regime, stop, size, exits. Only then place the order.

Make It Yours

Easy upgrades
Change the weightsEdit the 0.7 / 0.3 split if you care more about activity than trend.
Raise the filterSet MIN_VOLUME_USD to $5M or $10M if you only want the deepest markets.
Track OI changeSave each day’s CSV and compare open interest day over day: price up with OI rising is a stronger trend than price up with OI falling.
Add a volatility columnUse the same daily candles to calculate ATR%, so you know up front which names need wider stops and smaller size.
Run it automaticallyWindows Task Scheduler or a Mac/Linux cron job can run it at the same time every morning, so the CSV is waiting when you sit down.
If intraday setups are more your style, the same building blocks power the 1-2-3 Money Scanner, which looks for a specific Bollinger Band pattern across every perp instead of ranking momentum.

4 Common Screener Mistakes

❌
Buying the top of the list
The biggest 7-day mover is often the most extended. Wait for a pullback to a level, or skip it.
❌
Tweaking the settings every day
Change the weights after a bad day and you’ll never know if the scan works. Keep settings fixed for a month and judge it in your journal.
❌
Hammering the API
Removing the pause or running the scan every minute will hit the rate limit and get requests rejected. Once in the morning is plenty for a daily scan.
❌
Ignoring the crowded-funding line
A great-looking trend with extreme funding is where liquidation cascades start. Respect the warning, or at least size down.

Frequently Asked Questions

No. The script only uses Hyperliquid’s public Info API, which returns market data to anyone. It never asks for a wallet, private key or login, and it can’t place trades.
Usually a couple of minutes. The first request covers every market at once; the rest is one candle request per liquid market, spaced out to respect the API’s rate limit. The more markets pass the volume filter, the longer it takes.
No. By default the request returns the main perp markets only. HIP-3 markets live on separate perp dexes and spot uses a different request, so they’d need small additions to the script.
You shouldn’t. The scan only measures recent momentum, activity and funding. It knows nothing about support and resistance, upcoming news or your risk. Use it to decide where to look, then plan every trade on the chart with a stop.

Build Your Complete Trading System


The Bottom Line

A morning scan replaces “whatever I happened to click on” with the same measured look at every Hyperliquid perp, every day. Two free API calls give you price, volume, open interest and funding for the whole market; a short Python script turns that into a ranked watchlist with crowded trades flagged.
Keep the job of each tool clear: the scan decides where to look, the chart decides whether to trade, and the free Pre-Trade Checklist decides the stop and size. Run it for a month with fixed settings, log the results, and you’ll know whether it earns its two minutes.
New to Hyperliquid? Start With the Ultimate Guide
Wallet setup, first deposit and first trade — everything from scratch before you start building your own scans.
READ THE ULTIMATE GUIDE →
The Hyperliquid Blueprint — CryptoJag
📘 CryptoJag Digital Product
The Hyperliquid Blueprint
How to Connect, Trade, and Profit on the World’s Fastest DEX — including the platform walkthrough you need before turning a watchlist into live trades.
GET THE BLUEPRINT →
🎬 Video Courses
Watch. Follow along. Get it done.
Short, focused video courses — on screen, step by step.
🎬 Flagship
DeFi Demystified
9-module beginner to passive income
$97 one-time
Get Instant Access →
🎯 Mini
How to Cash Out
Wallet → exchange → bank
$17 one-time
Get It Now →
🦊 Micro
Add Network & Token
MetaMask fully set up
$37 one-time
Get It Now →
🎁 Trading Your Watchlist? — Get 4% Off
Sign Up via My Referral Link
Permanent 4% taker fee discount — and pair it with limit-order entries at your planned levels to cut costs further.
🇺🇸 US Residents: Use a VPN first — I use FastVPN by Namecheap.
Use code CRYPTOJAG or click the link above
🎬 Watch Me Run the Morning Scan Live
Python screeners, watchlist breakdowns and real Hyperliquid chart walkthroughs with the CryptoJag system.
▶ SUBSCRIBE ON YOUTUBE
Chris Ford — CryptoJag
C
— Chris
Founder · CryptoJag
I built my first Hyperliquid screener because I was tired of checking the same handful of coins every morning and missing the ones that were actually moving. It started as a rough script in Command Prompt and slowly became the first thing I run each day. It hasn’t made a single trade for me, and it’s not supposed to. What it does is make sure I spend my chart time on the right ten markets instead of the familiar ones.
This post is for educational purposes only and does not constitute financial or trading advice. The script and sample output are for education only; scan results are a watchlist, not trade recommendations. Sample output is hypothetical. API fields, limits and behavior may change, and you run any code at your own risk. All trading involves risk of loss. The Hyperliquid referral link earns CryptoJag a commission at no additional cost to you.

Leave a Reply

Your email address will not be published. Required fields are marked *

Crypto DeFi Trading and Passive Income with Hyperliquid
wpChatIcon