# ApexVol Options Analytics (pypi · apexvol-mcp)

Options analytics for AI assistants: chains, IV rank, VRP, Greeks, GEX, expected moves, screeners.

- Trust score: 64/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-20

## Components

- remote · `apexvol.com`: 37/100, [markdown](https://verifymcp.io/servers/ryansilk-apexvol-mcp/mcp-server.md), [page](https://verifymcp.io/servers/ryansilk-apexvol-mcp/mcp-server)
- pypi · `apexvol-mcp`: 64/100 (this document), [markdown](https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp.md), [page](https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp)

## Channel facts

- Registry: `pypi`
- Package: `apexvol-mcp`
- Version: `0.1.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-20.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised native-build step with no shell scripting around it.
  - 1 of 30 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 66/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 6981 tokens (~162/item across 43 items; 43 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add ryansilk-apexvol-mcp -- uvx apexvol-mcp
```

### Codex

```bash
codex mcp add ryansilk-apexvol-mcp -- uvx apexvol-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ryansilk-apexvol-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "apexvol-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ryansilk-apexvol-mcp --command uvx --arg apexvol-mcp
```

### Hermes

```yaml
mcp_servers:
  ryansilk-apexvol-mcp:
    command: "uvx"
    args: ["apexvol-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "ryansilk-apexvol-mcp": {
      "command": "uvx",
      "args": [
        "apexvol-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-15 (score 64)

First indexed and scored.

## MCP tools (43)

### `get_options_chain` (~226 tokens)

Get the options chain for a ticker.

Returns calls and puts with all Greeks, IV, volume, and open interest
per strike. Defaults to the nearest expiration and the 20 strikes each
side of the money — widen only when the analysis genuinely needs it.

Use this tool when the user asks about:
\- Options prices for a stock
\- Call or put prices at specific strikes
\- Volume and open interest data
\- Full options chain information

Args:
    ticker: Stock symbol (e.g., "AAPL", "SPY", "TSLA")
    expiration: Specific expiration date (YYYY-MM-DD); overrides num_expirations
    num_expirations: How many of the nearest expirations to include (1-10)
    strikes_around: Strikes per side of the money to keep (0 = full chain)

Returns:
    Options chain data with calls, puts, and metadata

Input parameters:

- `expiration`
- `num_expirations` (integer)
- `strikes_around` (integer)
- `ticker` (string, required)

### `get_expirations` (~89 tokens)

Get available expiration dates for a ticker.

Returns a list of all available options expiration dates,
useful for planning trades or understanding the term structure.

Use this tool when the user asks about:
\- When options expire
\- Available expiration dates
\- Weekly vs monthly expirations

Args:
    ticker: Stock symbol

Returns:
    List of expiration dates

Input parameters:

- `ticker` (string, required)

### `get_options_by_delta` (~175 tokens)

Find options at a specific delta.

Useful for finding options at standard delta levels (e.g., 0.30 delta calls
for covered calls, 0.16 delta puts for credit spreads).

Use this tool when the user asks about:
\- Options at a specific delta
\- 30 delta calls or 20 delta puts
\- Finding strikes by delta

Args:
    ticker: Stock symbol
    target_delta: Target delta (0.0 to 1.0, default 0.30)
    option_type: "call" or "put"
    expiration: Specific expiration or None for nearest

Returns:
    Strike and option details at the target delta

Input parameters:

- `expiration`
- `option_type` (string)
- `target_delta` (number)
- `ticker` (string, required)

### `get_stock_price` (~80 tokens)

Get current stock price and company information.

Returns the current price, bid/ask, and basic company stats.

Use this tool when the user asks about:
\- Current stock price
\- Bid/ask spread
\- Company information

Args:
    ticker: Stock symbol

Returns:
    Current price and company information

Input parameters:

- `ticker` (string, required)

### `calculate_expected_move` (~118 tokens)

Calculate the expected move based on ATM straddle pricing.

The expected move represents the market's implied price range
through the expiration date, derived from options pricing.

Use this tool when the user asks about:
\- Expected move or implied move
\- How much a stock might move
\- Options-implied price range
\- Event risk pricing

Args:
    ticker: Stock symbol
    expiration: Specific expiration or None for nearest

Returns:
    Expected move in dollars and percentage

Input parameters:

- `expiration`
- `ticker` (string, required)

### `get_historical_chain` (~165 tokens)

Get the options chain as it looked on a past trading day (EOD snapshot).

Historical chains go back years — see how an option was priced before
an earnings event, through a selloff, or at any point in its life.

Use this tool when the user asks about:
\- What an option was trading at on a past date
\- How a chain looked before/after an event
\- Backtesting entries against real historical quotes

Args:
    ticker: Stock symbol
    expiration: Expiration date YYYY-MM-DD
    trade_date: The historical date to snapshot YYYY-MM-DD

Returns:
    End-of-day chain snapshot for that date

Input parameters:

- `expiration` (string, required)
- `ticker` (string, required)
- `trade_date` (string, required)

### `get_iv_rank` (~171 tokens)

Get IV Rank and percentile for a stock.

IV Rank shows where current implied volatility stands relative to its
historical range. High IV Rank (>50) suggests elevated volatility,
potentially favorable for selling premium. Low IV Rank (<30) suggests
cheap options, potentially favorable for buying premium.

Use this tool when the user asks about:
\- Whether options are expensive or cheap
\- IV rank or IV percentile
\- Historical volatility context
\- Premium selling/buying opportunities

Args:
    ticker: Stock symbol (e.g., "AAPL", "SPY")
    lookback_days: Historical lookback period (default 252 = 1 year)

Returns:
    IV rank data with interpretation and strategy recommendations

Input parameters:

- `lookback_days` (integer)
- `ticker` (string, required)

### `get_volatility_cone` (~151 tokens)

Get volatility cone comparing current IV to historical realized volatility.

The volatility cone shows the historical distribution of realized
volatility at different time horizons, allowing comparison with
current implied volatility. This helps identify if options are
over/underpriced relative to historical moves.

Use this tool when the user asks about:
\- IV vs realized volatility comparison
\- Volatility cone analysis
\- Historical volatility distribution
\- Whether options are fairly priced

Args:
    ticker: Stock symbol
    periods: Comma-separated periods in days (default "10,20,30,60,90")

Returns:
    Volatility cone data with percentile rankings

Input parameters:

- `periods`
- `ticker` (string, required)

### `get_volatility_risk_premium` (~196 tokens)

Calculate the volatility risk premium (IV minus realized volatility).

VRP measures the spread between implied and realized volatility.
Positive VRP means options are pricing in more volatility than
actually occurs - favorable for sellers. Negative VRP means
options are cheap relative to actual moves.

Use this tool when the user asks about:
\- Volatility risk premium or VRP
\- IV vs RV spread
\- Whether to sell or buy volatility
\- Premium edge assessment

Args:
    ticker: Stock symbol
    lookback_days: Days for realized vol calculation (default 30)
    view: "current" (snapshot), "timeseries" (IV vs HV through time),
        or "by_expiration" (VRP per expiration)

Returns:
    VRP data with assessment and strategy recommendation

Input parameters:

- `lookback_days` (integer)
- `ticker` (string, required)
- `view` (string)

### `get_term_structure` (~106 tokens)

Get IV term structure across all expirations.

Shows how implied volatility varies across different expiration
dates. Contango (upward slope) is normal; backwardation suggests
near-term event risk.

Use this tool when the user asks about:
\- Term structure of volatility
\- Calendar spread opportunities
\- Event-driven vol bumps
\- Contango vs backwardation

Args:
    ticker: Stock symbol

Returns:
    Term structure data by expiration

Input parameters:

- `ticker` (string, required)

### `find_iv_opportunities` (~121 tokens)

Find IV mean reversion trading opportunities.

Identifies when IV is statistically extreme (>2 std from mean)
and suggests strategies to capture mean reversion.

Use this tool when the user asks about:
\- Mean reversion opportunities
\- Extreme IV levels
\- When to sell/buy volatility
\- IV statistical analysis

Args:
    ticker: Stock symbol
    z_score_threshold: Statistical threshold (default 2.0)

Returns:
    Opportunity assessment with strategy recommendations

Input parameters:

- `ticker` (string, required)
- `z_score_threshold` (number)

### `get_vix_snapshot` (~76 tokens)

Get the current VIX snapshot: level, change, and term-structure state.

Use this tool when the user asks about:
\- The VIX or overall market fear level
\- Whether index vol is elevated or calm
\- Vol regime context before a trade

Returns:
    VIX level, change, and context

### `get_monies_surface` (~164 tokens)

Get the ORATS monies volatility surface for a ticker.

\- "implied" (default): the market's current smoothed vol surface
\- "forecast": ORATS's model-forecast surface
\- "comparison": implied vs forecast side by side — where the model
  disagrees with the market (potential rich/cheap spots)

Use this tool when the user asks about:
\- The vol surface or smoothed IV by delta
\- Model-vs-market vol disagreement
\- Where IV looks rich or cheap across the surface

Args:
    ticker: Stock symbol
    surface: "implied", "forecast", or "comparison"

Returns:
    Monies surface rows per expiration

Input parameters:

- `surface` (string)
- `ticker` (string, required)

### `get_gex` (~173 tokens)

Get Gamma Exposure (GEX) levels and flip points.

GEX measures the gamma exposure of market makers at each strike level.
Positive GEX suggests dealer hedging will dampen moves (supportive).
Negative GEX suggests dealer hedging will amplify moves (volatile).

Use this tool when the user asks about:
\- Gamma exposure or GEX
\- Support and resistance from options
\- Dealer hedging levels
\- Market maker positioning

Args:
    ticker: Stock symbol (e.g., "SPY", "QQQ")
    expiration: Specific expiration or None for aggregate
    aggregate: Whether to aggregate across all expirations

Returns:
    GEX by strike, total GEX, and key levels

Input parameters:

- `aggregate` (boolean)
- `expiration`
- `ticker` (string, required)

### `get_charm_exposure` (~111 tokens)

Get charm (delta decay) exposure by strike.

Charm measures how delta changes with time. High charm exposure
indicates significant delta changes as time passes, affecting
hedging flows.

Use this tool when the user asks about:
\- Charm exposure
\- Delta decay
\- Time-based hedging flows

Args:
    ticker: Stock symbol
    expiration: Specific expiration or None for nearest

Returns:
    Charm exposure by strike

Input parameters:

- `expiration`
- `ticker` (string, required)

### `get_third_order_greeks` (~153 tokens)

Get third-order Greeks: Speed, Zomma, Color, Vomma, Ultima.

These advanced Greeks measure higher-order sensitivities:
\- Speed: Rate of change of gamma
\- Zomma: Gamma sensitivity to volatility
\- Color: Gamma sensitivity to time
\- Vomma: Vega sensitivity to volatility
\- Ultima: Vomma sensitivity to volatility

Use this tool when the user asks about:
\- Third-order Greeks
\- Speed, zomma, color
\- Advanced Greeks analysis

Args:
    ticker: Stock symbol
    expiration: Specific expiration or None for nearest

Returns:
    Third-order Greeks data

Input parameters:

- `expiration`
- `ticker` (string, required)

### `get_greeks_heatmap` (~153 tokens)

Get Greeks visualization data across strikes and expirations.

Returns a matrix of Greek values that can be visualized as a heatmap.
Useful for understanding the Greek landscape across the chain.

Use this tool when the user asks about:
\- Greeks across strikes
\- Delta/gamma/theta/vega heatmap
\- Greek distribution

Args:
    ticker: Stock symbol
    greek: Which Greek to show ("delta", "gamma", "theta", "vega")
    option_type: "calls" or "puts"

Returns:
    Heatmap matrix data with strikes and expirations

Input parameters:

- `greek` (string)
- `option_type` (string)
- `ticker` (string, required)

### `get_cross_index_gex` (~113 tokens)

Compare GEX across major indices.

Shows gamma exposure comparison between SPY, QQQ, IWM, and other
major indices to understand market-wide positioning.

Use this tool when the user asks about:
\- Cross-index GEX comparison
\- Market-wide gamma positioning
\- Index relative GEX

Args:
    tickers: Comma-separated tickers or None for defaults (SPY,QQQ,IWM,DIA)

Returns:
    GEX comparison across indices

Input parameters:

- `tickers`

### `get_options_flow` (~103 tokens)

Analyze options flow and unusual activity for a ticker.

Returns call/put volumes, premiums, and identifies unusual activity
that may indicate institutional positioning.

Use this tool when the user asks about:
\- Options flow or order flow
\- Call/put ratio
\- Unusual options activity
\- Large trades or sweeps

Args:
    ticker: Stock symbol

Returns:
    Flow analysis with volumes, premiums, and unusual activity

Input parameters:

- `ticker` (string, required)

### `get_smart_money_flow` (~97 tokens)

Identify institutional/smart money options trades.

Filters for large trades, sweeps, and block orders that may indicate
informed positioning.

Use this tool when the user asks about:
\- Smart money or institutional flow
\- Large options trades
\- Block trades or sweeps
\- Whale activity

Args:
    ticker: Stock symbol

Returns:
    Smart money flow patterns and significant trades

Input parameters:

- `ticker` (string, required)

### `scan_volatility_arb` (~84 tokens)

Scan for cross-index volatility arbitrage opportunities.

Identifies when implied volatility relationships between correlated
assets are mispriced, creating potential arbitrage opportunities.

Use this tool when the user asks about:
\- Volatility arbitrage
\- Cross-asset vol relationships
\- Vol dislocations
\- Relative value opportunities

Returns:
    Volatility arbitrage opportunities across indices

### `build_strategy` (~218 tokens)

Build an options strategy with optimal parameters.

Supports various strategy types and automatically selects strikes
based on target delta or other criteria.

Strategy types: iron_condor, credit_spread, debit_spread, straddle,
strangle, butterfly, calendar

Use this tool when the user asks about:
\- Building a specific strategy
\- Iron condor, credit spread, etc.
\- Strategy construction

Args:
    ticker: Stock symbol
    strategy_type: Type of strategy (iron_condor, credit_spread, etc.)
    expiration: Target expiration or None for nearest monthly
    width: Strike width for spreads in dollars; fractional widths
        like 2.5 are valid (default 5)
    target_delta: Target delta for strike selection (default 0.30)

Returns:
    Strategy details with legs, Greeks, and expected P&L

Input parameters:

- `expiration`
- `strategy_type` (string, required)
- `target_delta` (number)
- `ticker` (string, required)
- `width` (number)

### `analyze_strategy` (~126 tokens)

Analyze a custom options strategy.

Calculates full P&L profile, Greeks, probability of profit,
and risk metrics for a custom strategy.

Use this tool when the user asks about:
\- Analyzing a specific trade
\- Strategy P&L profile
\- Greeks for a position

Args:
    ticker: Stock symbol
    legs: Strategy legs in format "BUY 1 C 150, SELL 1 C 155"

Returns:
    Full analysis with P&L, Greeks, and probabilities

Input parameters:

- `legs` (string, required)
- `ticker` (string, required)

### `optimize_strategy` (~127 tokens)

Find optimal strikes for a strategy type.

Optimizes strike selection based on target criteria like max credit,
best risk/reward, or target probability.

Use this tool when the user asks about:
\- Best strikes for a strategy
\- Optimal iron condor strikes
\- Maximizing credit or probability

Args:
    ticker: Stock symbol
    strategy_type: Type of strategy
    target: Optimization target (credit, risk_reward, probability)

Returns:
    Optimized strategy parameters

Input parameters:

- `strategy_type` (string, required)
- `target` (string)
- `ticker` (string, required)

### `simulate_option_chain` (~242 tokens)

Re-price an options chain at a hypothetical stock price, DTE, and IV shift.

Black-Scholes "what-if" for the whole chain: what would these options
be worth if the stock were at X, with Y days left, and IV up/down Z%?

Use this tool when the user asks about:
\- What an option would be worth if the stock moves
\- How theta decay reshapes the chain over time
\- IV crush / IV spike what-ifs

Args:
    ticker: Stock symbol (server fetches the current chain)
    sim_price: Hypothetical stock price
    sim_dte: Days to expiration to simulate (0 = at expiry)
    iv_adjustment: IV shift in percent, -50 to +50 (e.g. -30 for IV crush)
    expiration: Expiration date YYYY-MM-DD (default: nearest)

Returns:
    The re-priced chain with Greeks at the simulated conditions

Input parameters:

- `expiration` (string)
- `iv_adjustment` (number)
- `sim_dte` (number, required)
- `sim_price` (number, required)
- `ticker` (string, required)

### `calculate_probability_of_profit` (~185 tokens)

Calculate the probability of profit for a set of option legs.

Uses N(d2)-based probabilities on the combined position payoff.

Use this tool when the user asks about:
\- Probability of profit / PoP for a trade
\- Odds a spread or condor expires profitable

Args:
    legs: JSON array of legs, e.g.
        '[{"option_type": "put", "action": "sell", "strike": 95, "iv": 32.5, "premium": 1.20, "quantity": 1}]'
        (iv accepts percent or decimal; premium is per share)
    stock_price: Current stock price
    days_to_exp: Days to expiration

Returns:
    Probability of profit percentage

Input parameters:

- `days_to_exp` (integer, required)
- `legs` (string, required)
- `stock_price` (number, required)

### `calculate_portfolio_greeks` (~228 tokens)

Calculate aggregate Greeks for a portfolio of positions.

Takes a portfolio of options positions and calculates net delta,
theta, and vega exposure plus a risk-level assessment.

Use this tool when the user asks about:
\- Portfolio Greeks
\- Net delta/theta/vega
\- Position exposure

Args:
    positions: JSON array of positions, e.g. '[{"ticker": "AAPL", "position_type": "STOCK", "quantity": 100, "current_price": 210}, {"ticker": "AAPL", "position_type": "CALL", "quantity": -2, "strike": 220, "expiration": "2026-08-21", "current_price": 4.10, "delta": 0.31, "theta": -8.2, "vega": 21.0}]'. Get option Greeks from get_options_chain first. Plain text ("AAPL 100 shares") works for stock-only portfolios.

Returns:
    Aggregated portfolio Greeks with risk assessment

Input parameters:

- `positions` (string, required)

### `run_scenario_analysis` (~302 tokens)

Run what-if scenario analysis on a portfolio.

Shows how portfolio value changes under different market conditions
(linear delta/vega/theta approximation).

Use this tool when the user asks about:
\- What-if scenarios
\- Portfolio P&L under different conditions
\- Price/vol sensitivity

Args:
    positions: JSON array of positions, e.g. '[{"ticker": "AAPL", "position_type": "STOCK", "quantity": 100, "current_price": 210}, {"ticker": "AAPL", "position_type": "CALL", "quantity": -2, "strike": 220, "expiration": "2026-08-21", "current_price": 4.10, "delta": 0.31, "theta": -8.2, "vega": 21.0}]'. Get option Greeks from get_options_chain first. Plain text ("AAPL 100 shares") works for stock-only portfolios.
    stock_move_pct: Percent stock price change to simulate (e.g. -5)
    iv_change_pct: Percent IV change to simulate (e.g. 25)
    days_forward: Days of time decay to advance

Returns:
    Estimated P&L under the scenario with per-Greek contributions

Input parameters:

- `days_forward` (integer)
- `iv_change_pct` (number)
- `positions` (string, required)
- `stock_move_pct` (number)

### `generate_stress_tests` (~212 tokens)

Run stress test scenarios on a portfolio.

Tests portfolio under extreme market conditions like crashes,
vol spikes, and rallies.

Use this tool when the user asks about:
\- Stress testing
\- Crash scenarios
\- Worst-case analysis

Args:
    positions: JSON array of positions, e.g. '[{"ticker": "AAPL", "position_type": "STOCK", "quantity": 100, "current_price": 210}, {"ticker": "AAPL", "position_type": "CALL", "quantity": -2, "strike": 220, "expiration": "2026-08-21", "current_price": 4.10, "delta": 0.31, "theta": -8.2, "vega": 21.0}]'. Get option Greeks from get_options_chain first. Plain text ("AAPL 100 shares") works for stock-only portfolios.

Returns:
    P&L under various stress scenarios

Input parameters:

- `positions` (string, required)

### `get_hedge_recommendations` (~296 tokens)

Get delta-hedge recommendations for a portfolio.

Computes net portfolio delta and suggests a stock hedge plus an
option-based alternative on the hedge ticker to reach the target
delta. Recommendations are share-equivalent, not beta-weighted.

Use this tool when the user asks about:
\- How to hedge a position or portfolio
\- Getting delta-neutral
\- Protective puts / reducing directional risk

Args:
    positions: JSON array of positions, e.g. '[{"ticker": "AAPL", "position_type": "STOCK", "quantity": 100, "current_price": 210}, {"ticker": "AAPL", "position_type": "CALL", "quantity": -2, "strike": 220, "expiration": "2026-08-21", "current_price": 4.10, "delta": 0.31, "theta": -8.2, "vega": 21.0}]'. Get option Greeks from get_options_chain first. Plain text ("AAPL 100 shares") works for stock-only portfolios.
    hedge_ticker: Instrument to hedge with (default SPY)
    target_delta: Desired net portfolio delta (default 0 = neutral)

Returns:
    Current vs target delta and concrete hedge suggestions

Input parameters:

- `hedge_ticker` (string)
- `positions` (string, required)
- `target_delta` (number)

### `get_earnings_calendar` (~116 tokens)

Get upcoming earnings announcements.

Shows companies reporting earnings in the upcoming period, including
expected move implied by options pricing.

Use this tool when the user asks about:
\- Upcoming earnings
\- What companies report this week
\- Earnings calendar

Args:
    days_ahead: Number of days to look ahead (default 7)
    min_market_cap: Minimum market cap filter in billions

Returns:
    List of upcoming earnings with expected moves

Input parameters:

- `days_ahead` (integer)
- `min_market_cap`

### `analyze_earnings_history` (~94 tokens)

Analyze historical earnings moves for a stock.

Shows how the stock has moved on past earnings announcements,
compared to the expected move implied by options.

Use this tool when the user asks about:
\- Historical earnings moves
\- Past earnings reactions
\- Beat/miss patterns
\- Options pricing accuracy

Args:
    ticker: Stock symbol

Returns:
    Historical earnings move analysis

Input parameters:

- `ticker` (string, required)

### `screen_market` (~346 tokens)

Screen the market for trading opportunities.

Preset screens run against the full ~6,000-ticker universe using bulk
data (cheap on quota). Pass screen_type="list" to fetch the catalog.

Screen types:
\- high_iv_rank / low_iv_rank: elevated or depressed IV vs 1-year range
\- high_vrp: IV rich vs realized — premium-selling edge
\- earnings_this_week: reporting in the next 7 days
\- high_skew: elevated put skew (hedging demand / fear)
\- steep_contango: large front-to-back IV spread (calendar spreads)
\- mean_reversion: IV/SPY ratio stretched vs its 1-year average
\- vol_pairs: rich-vs-cheap ticker pairs vs SPY
\- decorrelation: low-beta diversifiers
\- unusual_volume: options volume far above 20-day average
\- pin_risk: spot pinned near a large-OI strike into expiration

Use this tool when the user asks about:
\- Finding trading opportunities
\- Screening for high IV stocks
\- Unusual activity scan
\- What to trade

Args:
    screen_type: Screen name from the list above (or "list" for the catalog)
    limit: Maximum results to return (default 20)
    min_market_cap: Minimum market cap in dollars (0 = server default $1B)
    exclude_earnings_days: Skip tickers reporting within N days (0 = keep all)

Returns:
    Stocks matching the screen criteria

Input parameters:

- `exclude_earnings_days` (integer)
- `limit` (integer)
- `min_market_cap` (number)
- `screen_type` (string)

### `get_market_overview` (~82 tokens)

Get market-wide volatility overview.

Shows aggregate volatility metrics across major indices and sectors,
including VIX levels, put/call ratios, and GEX regime.

Use this tool when the user asks about:
\- Market overview
\- Overall market volatility
\- VIX and market sentiment
\- Broad market positioning

Returns:
    Market-wide volatility and positioning overview

### `get_economic_calendar` (~121 tokens)

Get the macro economic-event calendar (CPI, FOMC, jobs reports...).

Use this tool when the user asks about:
\- Upcoming macro events or data releases
\- When the next CPI/FOMC/NFP is
\- Event risk beyond earnings

Args:
    from_date: Start date YYYY-MM-DD (default today)
    to_date: End date YYYY-MM-DD (default ~1 week out)

Returns:
    Economic events with dates and importance

Input parameters:

- `from_date` (string)
- `to_date` (string)

### `get_ticker_analytics` (~352 tokens)

Get a specific per-ticker analytics view.

One tool, eight analyses — pick via the `analysis` argument:
\- "skew": put/call IV skew (view: "analysis" default, "history", "curvature")
\- "dividends": dividend history, yield, and ex-date behavior
\- "borrow_rate": stock borrow cost / hard-to-borrow signals (short-squeeze context)
\- "correlation": correlation and beta vs SPY and sector; pass compare_with
  to get the pairwise correlation vs another ticker instead
\- "hv_regimes": historical volatility regimes (view: "dashboard" default,
  "signals", "decomposition", "ex_earnings")
\- "price_context": price action + volatility briefing for orientation
\- "relative_value": is this ticker's vol rich or cheap vs its own history and peers
\- "greeks_exposure": dealer gamma/delta/vanna/charm exposure by strike

Args:
    ticker: Stock symbol (e.g., "AAPL")
    analysis: One of the eight analysis names above
    expiration: Optional YYYY-MM-DD filter (greeks_exposure only)
    days: History window in trading days (borrow_rate, relative_value, hv_regimes)
    view: Sub-view for skew / hv_regimes (see above)
    compare_with: Second ticker for pairwise correlation (correlation only)

Returns:
    The selected analytics payload with a compact summary

Input parameters:

- `analysis` (string, required)
- `compare_with` (string)
- `days` (integer)
- `expiration`
- `ticker` (string, required)
- `view` (string)

### `get_earnings_move_analysis` (~269 tokens)

Analyze how a stock moves around earnings and whether options misprice it.

Pick via the `analysis` argument:
\- "mispricing" (default): IV rank + VRP + expected-vs-actual history
  combined into an over/underpriced assessment
\- "historical_moves": realized post-earnings moves over several horizons
\- "expected_vs_actual": straddle-implied expected move vs what actually happened
\- "verdict": combined buy/sell-the-straddle verdict for the next earnings
\- "seasonality": monthly/quarterly return and volatility seasonality
\- "post_drift": post-earnings drift statistics over recent quarters
\- "iv_crush": IV build-up and crush pattern around past earnings

Use this when the user asks whether earnings options are over/underpriced,
how a stock usually moves on earnings, or if a straddle is worth buying.

Args:
    ticker: Stock symbol
    analysis: One of the seven analysis names above
    periods: Comma-separated day horizons for historical_moves (default "7,14,21,30")

Returns:
    The selected earnings analysis payload with a compact summary

Input parameters:

- `analysis` (string)
- `periods`
- `ticker` (string, required)

### `search_tickers` (~105 tokens)

Search or validate tickers against the platform's coverage universe.

Use before deep analysis when unsure a symbol is supported, or to
resolve a company name to its ticker.

Args:
    query: Symbol or company-name fragment (e.g. "NVDA" or "nvidia")
    limit: Max matches to return (1-20)

Returns:
    Ranked matches plus exact-match/supported flags

Input parameters:

- `limit` (integer)
- `query` (string, required)

### `scan_relative_value` (~136 tokens)

Market-wide relative-value scans.

\- "mean_reversion" (default): tickers whose IV/SPY ratio is stretched
  vs its own 1-year average — rich or cheap vol candidates
\- "pairs": rich-vs-cheap ticker pairs for pairs trading

Args:
    view: "mean_reversion" or "pairs"
    limit: Max results (1-50)
    threshold: Z-score threshold for mean_reversion (default 1.5)

Returns:
    Scan results ranked by stretch

Input parameters:

- `limit` (integer)
- `threshold` (number)
- `view` (string)

### `get_orats_cores` (~203 tokens)

Get raw ORATS "cores" analytics for a ticker — 340+ pre-computed fields.

The deepest single call available: IV surface summary metrics, IV/HV
history stats, term-structure slope/contango, earnings-move components,
borrow rates, betas, percentiles, and more, straight from the data
vendor. Use when the curated endpoints don't carry the specific field
you need.

Use this tool when the user asks about:
\- A specific ORATS field by name
\- Deep vendor-level analytics not in other tools
\- Bulk fundamentals+vol context for one ticker

Args:
    ticker: Stock symbol
    fields: Comma-separated field names for specific fields,
        "all" for the entire row, or empty for the curated ~45-field default

Returns:
    The requested cores fields (available_field_count says how many exist)

Input parameters:

- `fields` (string)
- `ticker` (string, required)

### `get_max_pain` (~128 tokens)

Get the max pain strike for a ticker.

Max pain is the strike where option holders lose the most at expiry
(and writers keep the most premium) — often watched as a magnet level
into expiration.

Use this tool when the user asks about:
\- Max pain level
\- Where the stock might pin at expiration
\- Option-writer positioning

Args:
    ticker: Stock symbol
    expiration: Expiration date YYYY-MM-DD (default: nearest)

Returns:
    Max pain strike with the loss profile by strike

Input parameters:

- `expiration`
- `ticker` (string, required)

### `get_volume_profile` (~120 tokens)

Get the option volume and open-interest profile by strike.

Shows where volume and OI concentrate across strikes — support/
resistance implied by positioning, plus notable OI changes.

Use this tool when the user asks about:
\- Where the open interest sits
\- Volume by strike
\- OI-implied support and resistance

Args:
    ticker: Stock symbol
    expiration: Expiration date YYYY-MM-DD (default: nearest)

Returns:
    Per-strike volume/OI profile

Input parameters:

- `expiration`
- `ticker` (string, required)

### `get_zero_dte` (~148 tokens)

Get 0DTE (same-day expiration) analytics for a ticker.

Includes 0DTE gamma exposure, gamma flip level, max pain, theta decay
projection, and the chain for today's expiration. Only meaningful for
tickers with daily expirations (SPY, QQQ, SPX...) on trading days.

Use this tool when the user asks about:
\- 0DTE setups or same-day options
\- Intraday gamma/pinning levels
\- Today's expiration chain

Args:
    ticker: Stock symbol with 0DTE listings (e.g., "SPY")

Returns:
    0DTE analytics payload

Input parameters:

- `ticker` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp#diagnostics

## Score history

- 2026-08-20: 64
- 2026-08-19: 64
- 2026-08-18: 64
- 2026-08-17: 64
- 2026-08-16: 64
- 2026-08-15: 64

## Links

- PyPI project: https://pypi.org/project/apexvol-mcp/
- Socket report: https://socket.dev/pypi/package/apexvol-mcp
- Repository: https://github.com/ryansilk/apexvol-mcp
- Website: https://apexvol.com/learn/claude-options-data-mcp
- Changelog RSS feed: https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp.json
- HTML version of this page: https://verifymcp.io/servers/ryansilk-apexvol-mcp/apexvol-mcp