Agent skill

Stock Liquidity

by himself65 in himself65/finance-skills

Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates…

MITAuto-check passedBusiness, Finance & HR

Install Stock Liquidity

skills CLI
$ npx skills add himself65/finance-skills --skill stock-liquidity -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install himself65/finance-skills stock-liquidity --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/himself65/finance-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/market-analysis/skills/stock-liquidity .claude/skills/stock-liquidity && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
stock-liquidity
GitHub stars
3.4k
Token cost
~4.9k tokens
SKILL.md length
1,308 words
Files
3 (incl. references)
Skills in repo
25
Repo updated
First seen
Licence
MIT

At a glance

Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates…

  • Works in 3 steps: Ensure Dependencies Are Available → Route to the Correct Sub-Skill → Respond to the User
  • The user asks about liquidity
  • SKILL.md covers Step 1: Ensure Dependencies…, Step 2: Route to the Correct…, Sub-Skill A: Liquidity Dashboard and Sub-Skill B: Spread Analysis, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Stock Liquidity is an agent skill from himself65/finance-skills. Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates, turnover ratio, and Amihud illiquidity, rolled into a liquidity grade. Use this skill whenever the user asks about liquidity or trading costs — how easily a position can be entered or exited, what a large order would do to the price, spread or execution-cost estimates, order book depth, volume patterns, or liquidity…

Its SKILL.md is about 4.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `README.md` and `references/liquidity_reference.md`).

It sits in Business, Finance & HR, covering Stock and market analysis and Trading and backtesting. It works with yfinance. The repository describes itself as: A collection of skills for AI financial analysis. The licence is MIT.

When your agent uses it

  • The user asks about liquidity
  • Trading costs — how easily a position can be entered
  • What a large order would do to the price
  • Execution-cost estimates

Example prompts

  • “/stock-liquidity”

Requirements

  • Python 3

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Ensure Dependencies Are Available
  2. Route to the Correct Sub-Skill
  3. Respond to the User

What it can do on your machine

Read from SKILL.md and the folder at commit 01fc7b4. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are python).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Stock Liquidity loads about 4.9k tokens when it runs, and up to ~8.3k if it reads all its reference files. Until then it costs about 153 tokens; SKILL.md has 1,308 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~153
When it runs · the whole SKILL.md, loaded when a task matches
~4.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~8.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from himself65/finance-skills at commit 01fc7b4, republished under its MIT licence (© himself65). 1,308 words, ~4,924 tokens.

Download SKILL.mdSave it as .claude/skills/stock-liquidity/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
stock-liquidity
description
Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates, turnover ratio, and Amihud illiquidity, rolled into a liquidity grade. Use this skill whenever the user asks about liquidity or trading costs — how easily a position can be entered or exited, what a large order would do to the price, spread or execution-cost estimates, order book depth, volume patterns, or liquidity comparisons — especially for small caps, penny stocks, and thinly traded names.

Stock Liquidity Analysis Skill

Analyzes stock liquidity across multiple dimensions — bid-ask spreads, volume patterns, order book depth, estimated market impact, and turnover ratios — using data from Yahoo Finance via yfinance.

Liquidity matters because it determines the real cost of trading. The quoted price is not what you actually pay — spreads, slippage, and market impact all eat into returns, especially for larger positions or less liquid names.

Important: This is for research and educational purposes only. Not financial advice. yfinance is not affiliated with Yahoo, Inc.


Step 1: Ensure Dependencies Are Available

Current environment status:

!`python3 -c "exec('try:\n import yfinance, pandas, numpy\n print(f\'yfinance={yfinance.__version__} pandas={pandas.__version__} numpy={numpy.__version__}\')\nexcept Exception:\n print(\'DEPS_MISSING\')')"`

If DEPS_MISSING, install required packages:

python
import subprocess, sys
subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "yfinance", "pandas", "numpy"])

If already installed, skip and proceed.


Step 2: Route to the Correct Sub-Skill

Classify the user's request and jump to the matching section. If the user asks for a general liquidity assessment without specifying a particular metric, run Sub-Skill A (Liquidity Dashboard) which computes all key metrics together.

User RequestRoute ToExamples
General liquidity check, "how liquid is X"Sub-Skill A: Liquidity Dashboard"how liquid is AAPL", "liquidity analysis for TSLA", "is this stock liquid enough"
Bid-ask spread, trading costs, effective spreadSub-Skill B: Spread Analysis"bid-ask spread for AMD", "what's the spread on NVDA options", "trading cost estimate"
Volume, ADTV, dollar volume, volume profileSub-Skill C: Volume Analysis"volume analysis MSFT", "average daily volume", "volume profile for SPY"
Order book depth, market depth, level 2Sub-Skill D: Order Book Depth"order book depth for AAPL", "market depth", "show me the book"
Market impact, slippage, execution cost for large ordersSub-Skill E: Market Impact"how much would 50k shares move the price", "slippage estimate", "market impact of $1M order"
Turnover ratio, trading activity relative to floatSub-Skill F: Turnover Ratio"turnover ratio for GME", "float turnover", "how actively traded is this"
Compare liquidity across multiple stocksSub-Skill A (multi-ticker mode)"compare liquidity AAPL vs TSLA", "which is more liquid AMD or INTC"
Defaults
ParameterDefault
Lookback period3mo (3 months)
Data interval1d (daily)
Market impact modelSquare-root model
Intraday interval (when needed)5m

Sub-Skill A: Liquidity Dashboard

Goal: Produce a comprehensive liquidity snapshot combining all key metrics for one or more tickers.

A1: Fetch data and compute all metrics
python
import yfinance as yf
import pandas as pd
import numpy as np

def liquidity_dashboard(ticker_symbol, period="3mo"):
    ticker = yf.Ticker(ticker_symbol)
    info = ticker.info
    hist = ticker.history(period=period)

    if hist.empty:
        return None

    # --- Spread metrics (from current quote) ---
    bid = info.get("bid", None)
    ask = info.get("ask", None)
    current_price = info.get("currentPrice") or info.get("regularMarketPrice") or hist["Close"].iloc[-1]

    spread = None
    spread_pct = None
    if bid and ask and bid > 0 and ask > 0:
        spread = round(ask - bid, 4)
        midpoint = (ask + bid) / 2
        spread_pct = round((spread / midpoint) * 100, 4)

    # --- Volume metrics ---
    avg_volume = hist["Volume"].mean()
    median_volume = hist["Volume"].median()
    avg_dollar_volume = (hist["Close"] * hist["Volume"]).mean()
    volume_std = hist["Volume"].std()
    volume_cv = volume_std / avg_volume if avg_volume > 0 else None  # coefficient of variation

    # --- Turnover ratio ---
    shares_outstanding = info.get("sharesOutstanding", None)
    float_shares = info.get("floatShares", None)
    base_shares = float_shares or shares_outstanding
    turnover_ratio = round(avg_volume / base_shares, 6) if base_shares else None

    # --- Amihud illiquidity ratio ---
    # Average of |daily return| / daily dollar volume
    returns = hist["Close"].pct_change().dropna()
    dollar_volume = (hist["Close"] * hist["Volume"]).iloc[1:]  # align with returns
    amihud_values = returns.abs() / dollar_volume
    amihud = amihud_values[amihud_values.replace([np.inf, -np.inf], np.nan).notna()].mean()

    # --- Market impact estimate (square-root model) ---
    # For a hypothetical order of 1% of ADV
    adv = avg_volume
    order_size = adv * 0.01
    daily_volatility = returns.std()
    sigma = daily_volatility
    participation_rate = order_size / adv if adv > 0 else 0
    impact_bps = sigma * np.sqrt(participation_rate) * 10000  # in basis points

    return {
        "ticker": ticker_symbol,
        "current_price": round(current_price, 2),
        "bid": bid,
        "ask": ask,
        "spread": spread,
        "spread_pct": spread_pct,
        "avg_daily_volume": int(avg_volume),
        "median_daily_volume": int(median_volume),
        "avg_dollar_volume": round(avg_dollar_volume, 0),
        "volume_cv": round(volume_cv, 3) if volume_cv else None,
        "shares_outstanding": shares_outstanding,
        "float_shares": float_shares,
        "turnover_ratio": turnover_ratio,
        "amihud_illiquidity": round(amihud * 1e9, 4) if not np.isnan(amihud) else None,
        "daily_volatility": round(daily_volatility * 100, 2),
        "impact_1pct_adv_bps": round(impact_bps, 2),
        "observations": len(hist),
    }
A2: Interpret and present

Present as a summary card. For the Amihud illiquidity ratio, multiply by 1e9 for readability (standard convention).

Liquidity grade (use these rough thresholds for US equities):

GradeAvg Dollar VolumeSpread (%)Amihud (×10⁹)
Very High> $500M/day< 0.03%< 0.01
High$50M–$500M/day0.03–0.10%0.01–0.1
Moderate$5M–$50M/day0.10–0.50%0.1–1.0
Low$500K–$5M/day0.50–2.00%1.0–10
Very Low< $500K/day> 2.00%> 10

When comparing multiple tickers, show a side-by-side table and highlight which is more liquid and why.


Sub-Skill B: Spread Analysis

Goal: Detailed bid-ask spread analysis including current spread, historical context from options data, and effective spread estimates.

B1: Current spread from quote
python
import yfinance as yf

def spread_analysis(ticker_symbol):
    ticker = yf.Ticker(ticker_symbol)
    info = ticker.info

    bid = info.get("bid", 0)
    ask = info.get("ask", 0)
    bid_size = info.get("bidSize", None)
    ask_size = info.get("askSize", None)
    current_price = info.get("currentPrice") or info.get("regularMarketPrice", 0)

    result = {"bid": bid, "ask": ask, "bid_size": bid_size, "ask_size": ask_size}

    if bid > 0 and ask > 0:
        midpoint = (bid + ask) / 2
        result["absolute_spread"] = round(ask - bid, 4)
        result["relative_spread_pct"] = round((ask - bid) / midpoint * 100, 4)
        result["relative_spread_bps"] = round((ask - bid) / midpoint * 10000, 2)
    return result
B2: Options spread context

Options data from yfinance includes bid/ask for each strike, which gives a sense of derivatives liquidity. Use the nearest expiration, extract near-the-money calls and puts, and compute spread and spread percentage for each.

See references/liquidity_reference.md § "Options Spread Analysis" for the full code template.

B3: Present results

Show:

  • Current quoted spread (absolute, relative %, basis points)
  • Bid/ask sizes if available
  • Near-the-money options spreads for context
  • How the spread compares to typical ranges for this market cap tier

Sub-Skill C: Volume Analysis

Goal: Analyze trading volume patterns — averages, trends, relative volume, and dollar volume.

C1: Compute volume metrics
python
import yfinance as yf
import pandas as pd
import numpy as np

def volume_analysis(ticker_symbol, period="3mo"):
    ticker = yf.Ticker(ticker_symbol)
    hist = ticker.history(period=period)

    if hist.empty:
        return None

    vol = hist["Volume"]
    close = hist["Close"]
    dollar_vol = vol * close

    # Relative volume (today vs average)
    rvol = vol.iloc[-1] / vol.mean() if vol.mean() > 0 else None

    # Volume trend (linear regression slope over the period)
    x = np.arange(len(vol))
    slope, _ = np.polyfit(x, vol.values, 1) if len(vol) > 1 else (0, 0)
    trend_pct = (slope * len(vol)) / vol.mean() * 100  # % change over period

    # Volume profile by day of week
    hist_copy = hist.copy()
    hist_copy["DayOfWeek"] = hist_copy.index.dayofweek
    day_names = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri"}
    vol_by_day = hist_copy.groupby("DayOfWeek")["Volume"].mean()
    vol_by_day.index = vol_by_day.index.map(day_names)

    # High/low volume days
    high_vol_days = hist.nlargest(5, "Volume")[["Close", "Volume"]]
    low_vol_days = hist.nsmallest(5, "Volume")[["Close", "Volume"]]

    return {
        "avg_volume": int(vol.mean()),
        "median_volume": int(vol.median()),
        "avg_dollar_volume": round(dollar_vol.mean(), 0),
        "current_volume": int(vol.iloc[-1]),
        "relative_volume": round(rvol, 2) if rvol else None,
        "volume_trend_pct": round(trend_pct, 1),
        "volume_by_day": vol_by_day.to_dict(),
        "high_vol_days": high_vol_days,
        "low_vol_days": low_vol_days,
        "max_volume": int(vol.max()),
        "min_volume": int(vol.min()),
    }
C2: Present results

Show:

  • Average daily volume (shares and dollar) with median for comparison
  • Relative volume (RVOL) — today's volume vs. the average. RVOL > 1.5 is elevated; RVOL < 0.5 is unusually quiet
  • Volume trend — is trading activity increasing or declining?
  • Day-of-week pattern (if meaningful variation exists)
  • Top 5 highest-volume days with context (earnings? news?)

Sub-Skill D: Order Book Depth

Goal: Estimate order book depth using available bid/ask data from the equity quote and options chain.

Yahoo Finance does not provide full Level 2 / order book data. Be upfront about this limitation. What we can do:

  1. Equity quote: bid, ask, bid size, ask size (top of book only)
  2. Options chain: bid/ask and open interest across strikes give a proxy for derivatives depth
  3. Intraday volume distribution: how volume is distributed within the day suggests how deep the continuous market is
D1: Gather available depth data

Collect three data points:

  1. Top of book — bid, ask, bidSize, askSize from ticker.info
  2. Intraday volume distribution — 5-min bars over the last 5 days, grouped by time-of-day and normalized to percentage of daily volume
  3. Options open interest — total call/put OI and volume from the nearest expiration as a derivatives depth proxy

See references/liquidity_reference.md § "Order Book Depth Proxy" for the full code template.

Show full SKILL.md (539 more words)Show less
D2: Present results

Show:

  • Top of book: current bid/ask with sizes
  • Intraday volume shape: where volume concentrates (open/close vs. midday)
  • Options depth: total open interest and volume as a proxy for derivatives liquidity
  • Honest limitation: "Yahoo Finance provides top-of-book only. For full Level 2 depth, a direct market data feed (e.g., NYSE OpenBook, NASDAQ TotalView) is needed."

Sub-Skill E: Market Impact

Goal: Estimate how much a given order size would move the price, using the square-root market impact model.

The standard model in practice is: Impact (%) = σ × √(Q / V) where σ is daily volatility, Q is order size in shares, and V is average daily volume. This is a simplified version of the Almgren-Chriss framework used by institutional traders.

E1: Compute market impact estimate
python
import yfinance as yf
import numpy as np

def market_impact(ticker_symbol, order_shares=None, order_dollars=None, period="3mo"):
    ticker = yf.Ticker(ticker_symbol)
    hist = ticker.history(period=period)
    info = ticker.info

    if hist.empty:
        return None

    current_price = info.get("currentPrice") or hist["Close"].iloc[-1]
    avg_volume = hist["Volume"].mean()
    daily_volatility = hist["Close"].pct_change().dropna().std()

    # Determine order size in shares
    if order_dollars and not order_shares:
        order_shares = order_dollars / current_price
    elif not order_shares:
        # Default: estimate for various sizes
        order_shares = avg_volume * 0.01  # 1% of ADV

    participation_rate = order_shares / avg_volume if avg_volume > 0 else 0
    pct_adv = (order_shares / avg_volume * 100) if avg_volume > 0 else 0

    # Square-root impact model
    impact_pct = daily_volatility * np.sqrt(participation_rate) * 100
    impact_bps = impact_pct * 100
    impact_dollars = impact_pct / 100 * current_price * order_shares

    # Generate impact curve for multiple order sizes
    sizes = [0.001, 0.005, 0.01, 0.02, 0.05, 0.10, 0.20, 0.50]  # as fraction of ADV
    curve = []
    for s in sizes:
        q = avg_volume * s
        imp = daily_volatility * np.sqrt(s) * 100
        curve.append({
            "pct_adv": round(s * 100, 1),
            "shares": int(q),
            "dollars": round(q * current_price, 0),
            "impact_bps": round(imp * 100, 1),
            "impact_dollars_per_share": round(imp / 100 * current_price, 4),
        })

    return {
        "ticker": ticker_symbol,
        "current_price": round(current_price, 2),
        "avg_daily_volume": int(avg_volume),
        "daily_volatility_pct": round(daily_volatility * 100, 2),
        "order_shares": int(order_shares),
        "order_dollars": round(order_shares * current_price, 0),
        "pct_of_adv": round(pct_adv, 2),
        "estimated_impact_bps": round(impact_bps, 1),
        "estimated_impact_pct": round(impact_pct, 4),
        "estimated_impact_total_dollars": round(impact_dollars, 2),
        "impact_curve": curve,
    }
E2: Present results

Show:

  • The estimated impact for the user's specific order size
  • An impact curve table showing how cost scales with order size
  • Context: "This uses the square-root market impact model, a standard institutional estimate. Actual impact depends on execution strategy (VWAP, TWAP, etc.), time of day, and current market conditions."
  • Above ~25 bps, note that the order is large for the stock's liquidity; above ~50 bps, flag it clearly and suggest the user consider algorithmic execution or splitting the order across days

Sub-Skill F: Turnover Ratio

Goal: Measure how actively a stock trades relative to its shares outstanding and free float.

F1: Compute turnover metrics
python
import yfinance as yf
import pandas as pd
import numpy as np

def turnover_analysis(ticker_symbol, period="3mo"):
    ticker = yf.Ticker(ticker_symbol)
    hist = ticker.history(period=period)
    info = ticker.info

    if hist.empty:
        return None

    avg_volume = hist["Volume"].mean()
    shares_outstanding = info.get("sharesOutstanding")
    float_shares = info.get("floatShares")

    result = {
        "avg_daily_volume": int(avg_volume),
        "shares_outstanding": shares_outstanding,
        "float_shares": float_shares,
    }

    if shares_outstanding:
        daily_turnover = avg_volume / shares_outstanding
        result["daily_turnover_ratio"] = round(daily_turnover, 6)
        result["annualized_turnover"] = round(daily_turnover * 252, 2)
        result["days_to_trade_float"] = round(
            (float_shares or shares_outstanding) / avg_volume, 1
        ) if avg_volume > 0 else None

    if float_shares:
        float_turnover = avg_volume / float_shares
        result["float_turnover_daily"] = round(float_turnover, 6)
        result["float_turnover_annualized"] = round(float_turnover * 252, 2)

    # Turnover trend
    vol = hist["Volume"]
    base = float_shares or shares_outstanding
    if base:
        hist_copy = hist.copy()
        hist_copy["turnover"] = hist_copy["Volume"] / base
        recent_turnover = hist_copy["turnover"].tail(20).mean()
        older_turnover = hist_copy["turnover"].head(20).mean()
        if older_turnover > 0:
            result["turnover_trend_pct"] = round(
                (recent_turnover - older_turnover) / older_turnover * 100, 1
            )

    return result
F2: Present results

Show:

  • Daily and annualized turnover ratios (vs. outstanding and float)
  • "Days to trade the float" — how many days at average volume to turn over the entire free float
  • Turnover trend — is the stock becoming more or less actively traded?
  • Context:
Turnover (Annualized)Interpretation
> 500%Extremely active — likely speculative or momentum-driven
100–500%Actively traded
30–100%Moderate activity
< 30%Thinly traded — likely institutional buy-and-hold or neglected

Step 3: Respond to the User

After running the appropriate sub-skill:

Always include
  • The lookback period used for historical metrics
  • The data timestamp — spreads and quotes are snapshots, not real-time
  • Any tickers that returned empty data (invalid symbol, delisted, etc.)
Always caveat
  • Yahoo Finance quote data has a 15-minute delay for most exchanges — spreads shown may not reflect the current live market
  • Full order book (Level 2) data is not available through Yahoo Finance
  • Market impact estimates are models, not guarantees — actual execution costs depend on strategy, timing, and market conditions
  • Liquidity can change rapidly — a stock that's liquid today may not be tomorrow (especially around events, halts, or during extended hours)
Practical guidance (mention when relevant)
  • Position sizing: If estimated impact exceeds ~25 bps, the position may be too large for the stock's liquidity (see the thresholds in Sub-Skill E)
  • Small/micro-cap warning: Stocks with < $1M daily dollar volume require careful execution
  • Spread costs compound: A 0.10% spread on a round-trip (buy + sell) costs 0.20% — this adds up for active strategies
  • Illiquidity premium: Less liquid stocks historically earn higher returns as compensation — but the transaction costs can eat this premium

Present liquidity data and let the user make their own decisions; don't recommend specific trades.


Reference Files

  • references/liquidity_reference.md — Detailed formulas, extended code templates, metric interpretation guides, and academic references for all liquidity measures

Read the reference file when you need exact formulas, edge case handling, or deeper background on liquidity metrics.

© himself65, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in plugins/market-analysis/skills/stock-liquidity of himself65/finance-skills.

  • SKILL.md
  • README.md
  • references/liquidity_reference.md

Open the folder on GitHubat commit 01fc7b4

Compare with similar skills

Stock Liquidity next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Stock Liquidity compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Stock Liquidity this skillhimself65/finance-skills3.4k—~4.9kAutomated safety check: PassMIT
Regimejackson-video-resources/markov-hedge-fund-method484—~1.6kAutomated safety check: PassCustom licence
yfinance Market DataHKUDS/Vibe-Trading35k—~2.2kAutomated safety check: PassMIT
Vibe-Trading Finance ToolkitHKUDS/Vibe-Trading35k—~6.5kAutomated safety check: PassMIT
Fundamental Factor ScreeningHKUDS/Vibe-Trading35k—~1.7kAutomated safety check: PassMIT
Minute-Level Data and BacktestingHKUDS/Vibe-Trading35k—~868Automated safety check: PassMIT

Similar skills

  • Regime

    jackson-video-resources/markov-hedge-fund-method

    Detect the market regime (Bull / Bear / Sideways) for ANY asset and turn it into a tradeable signal or a risk filter.

    484 GitHub stars~1.6k tokensUpdated 4 mo ago
    Business, Finance & HRAuto-check passed
  • yfinance Market Data

    HKUDS/Vibe-Trading

    Pulls price history and company research data for US, Hong Kong and Canadian stocks, ETFs and indices from Yahoo Finance, with no API key.

    35k GitHub stars~2.2k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Finance research toolkit with backtesting, factor analysis, a library of prebuilt alphas, options pricing and a Shadow Account loop that tests rules extracted from your trade journal.

    35k GitHub stars~6.5k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Builds value or growth stock screens from PE, PB, ROE and financial statement fields for backtests, using tushare data for A-shares and yfinance for Hong Kong and US stocks.

    35k GitHub stars~1.7k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Fetches minute candlesticks from OKX, Tushare or yfinance, computes intraday VWAP, TWAP and volume distribution, and runs minute-level backtests by setting an interval in config.json.

    35k GitHub stars~868 tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Market Data Source Router

    HKUDS/Vibe-Trading

    Maps backtest data sources and research data needs to the right provider or tool, with each one's markets, required environment keys and network constraints.

    35k GitHub stars~2.4k tokensUpdated today
    Business, Finance & HRAuto-check passed

More from himself65/finance-skills

All 25 skills in this repo
  • Company Valuation

    himself65/finance-skills

    Estimate a public company's intrinsic value with DCF, relative (peer multiple), and sum-of-the-parts (SOTP) methods, then blend them into an implied share price with upside/downside vs the market…

    3.4k GitHub stars~3.3k tokensUpdated 6 days ago
    Auto-check passed
  • Discord Reader

    himself65/finance-skills

    Read Discord for financial research through opencli connected to the Discord desktop app: servers, channels, members, recent messages in the active channel, and message search.

    3.4k GitHub stars~1.8k tokensUpdated 6 days ago
    Auto-check passed
  • Earnings Preview

    himself65/finance-skills

    Build a pre-earnings briefing for a stock from Yahoo Finance data (yfinance): the upcoming report date and timing, consensus EPS and revenue estimates with their range, the beat/miss track record…

    3.4k GitHub stars~1.4k tokensUpdated 6 days ago
    Auto-check passed
  • Earnings Recap

    himself65/finance-skills

    Analyze a company's most recent (or a specified past) earnings report from Yahoo Finance data (yfinance): actual vs estimated EPS, surprise size, revenue and margin trends, and the stock's price…

    3.4k GitHub stars~1.7k tokensUpdated 6 days ago
    Auto-check passed
  • Estimate Analysis

    himself65/finance-skills

    Analyze sell-side analyst estimates and how they are changing, using Yahoo Finance data (yfinance): EPS and revenue consensus by period, estimate ranges and dispersion, revision trends over…

    3.4k GitHub stars~1.8k tokensUpdated 6 days ago
    Auto-check passed
  • Finance Sentiment

    himself65/finance-skills

    Fetch normalized stock sentiment across Reddit, X.com, financial news, and Polymarket from the Adanos Finance API: buzz score, bullish percentage, mention or trade counts, and trend.

    3.4k GitHub stars~1.3k tokensUpdated 6 days ago
    Auto-check passed

Works with

Questions about Stock Liquidity

What does Stock Liquidity do?

Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates…. Stock Liquidity is an agent skill from himself65/finance-skills. Analyze how liquid a stock is using Yahoo Finance data (yfinance): bid-ask spreads, volume and dollar volume (ADTV), top-of-book and options depth, square-root market impact and slippage estimates, turnover ratio, and Amihud illiquidity, rolled into a liquidity grade.

When should I use Stock Liquidity?

Stock Liquidity fits situations like: the user asks about liquidity; trading costs — how easily a position can be entered; what a large order would do to the price; execution-cost estimates.

How do I install Stock Liquidity in Claude Code?

Run `npx skills add himself65/finance-skills --skill stock-liquidity -a claude-code`. Or copy the skill folder (plugins/market-analysis/skills/stock-liquidity in himself65/finance-skills) into .claude/skills/stock-liquidity in your project. Claude Code loads it when a task matches its description.

How do I install Stock Liquidity in Codex?

Run `npx skills add himself65/finance-skills --skill stock-liquidity -a codex`. Or copy the skill folder (plugins/market-analysis/skills/stock-liquidity in himself65/finance-skills) into .agents/skills/stock-liquidity in your project. Codex loads it when a task matches its description.

Can I use Stock Liquidity in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add himself65/finance-skills --skill stock-liquidity -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/stock-liquidity, .gemini/skills/stock-liquidity, .github/skills/stock-liquidity and .opencode/skills/stock-liquidity in your project.

What does Stock Liquidity need to run?

SKILL.md names no scripts, command-line tools or credentials: Stock Liquidity is instructions for the agent only. Our summary lists: Python 3.

Does Stock Liquidity access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Stock Liquidity safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Stock Liquidity use?

Stock Liquidity is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Stock Liquidity use?

About 4.9k tokens (SKILL.md is roughly 20k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.4k tokens, read only when the agent opens those files.

What are the alternatives to Stock Liquidity?

Skills that share tags, products or a category with Stock Liquidity: Regime (jackson-video-resources/markov-hedge-fund-method, 484 stars), yfinance Market Data (HKUDS/Vibe-Trading, 35k stars), Vibe-Trading Finance Toolkit (HKUDS/Vibe-Trading, 35k stars) and Fundamental Factor Screening (HKUDS/Vibe-Trading, 35k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Stock Liquidity?

himself65 (a GitHub user) maintains it in himself65/finance-skills, which has 3,388 GitHub stars. The repository holds 25 skills in this directory. The repository was last updated on October 5, 2026.

Source: himself65/finance-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.