Skip to main content
Glama
tickscope-mcp

tickscope-mcp

by seungdori

Tickscope MCP

Real-time, free crypto market data for any AI agent — via MCP.

PyPI Python License: MIT CI Ruff Checked with mypy MCP

English · 한국어 · 中文 · 日本語

Tickscope demo

Tickscope is a self-hostable Model Context Protocol server that gives any MCP client (Claude Code, Cursor, Codex, Gemini CLI, …) real-time and historical crypto market data for free. It keeps exchange WebSocket connections warm in the background, so your agent reads prices that are fresh to the sub-second, straight from a live connection. The same server covers 73 technical indicators and chart-structure recognition, with no API keys.

⚠️ Educational/research tool. It does not provide financial, investment, or trading advice, and it does not guarantee data accuracy or timeliness.


Contents

Related MCP server: crypto-powerdata-mcp

Why

Trading agents are exploding, yet their data layer stays fragmented, REST-poll-only, and often locked behind a paywall. Tickscope gives those agents real-time, free market data from one server — many exchanges, no API keys.

See it run

uv run examples/demo.py            # live BTC/USDT walkthrough (no API keys)
uv run examples/demo.py ETH/USDT 4h

A colorized terminal walkthrough — cold→warm freshness (REST → WebSocket), indicators with signals, divergence, market structure, and support/resistance — against live Binance/Bybit/OKX. See examples/RECORDING.md to turn it into the GIF above.

30-second install

uvx tickscope-mcp

Register it with your client (Claude Code example, examples/claude_code_config.json):

{
  "mcpServers": {
    "tickscope": {
      "command": "uvx",
      "args": ["tickscope-mcp"],
      "env": {
        "TICKSCOPE_EXCHANGES": "binance,bybit,okx",
        "TICKSCOPE_DEFAULT_EXCHANGE": "binance"
      }
    }
  }
}

Cursor, Codex and Gemini CLI use the same command/args/env shape in their respective MCP config files.

Supported exchanges

Exchange

REST

WebSocket

Binance

✅

✅

Bybit

✅

✅

OKX

✅

✅

Any ccxt-supported exchange can be enabled via TICKSCOPE_EXCHANGES. Public data only — no keys required.

Tools

Tool

What it does

list_exchanges

Configured exchanges + default

list_symbols

Tradable symbols (filter by quote/search)

get_ticker

Current price snapshot (primary quote tool)

get_recent_trades

Recent executed trades from the live buffer

get_ohlcv

Historical candles (DuckDB-cached)

get_orderbook

Order book snapshot + spread

compute_indicators

73 indicators (RSI/MACD/Supertrend/WaveTrend/Squeeze/…) with derived signals

detect_divergence

Regular/hidden bullish & bearish divergence (price vs oscillator)

detect_cross

Pine-style ta.crossover/ta.crossunder between any two series

detect_patterns

Candlestick patterns (engulfing, hammer, stars, …) with bias

analyze_structure

Market structure: swings, trend, BOS / CHoCH

find_support_resistance

Clustered support/resistance zones from pivots

deep_analyze

Multi-timeframe read: trend confluence + market-state context + historical signal performance, with a synthesized verdict

screen_market

Scan many symbols by indicator/price filters

get_aggregated_price

Volume-weighted price + cross-exchange spread (arbitrage)

get_funding_rate

Perpetual funding rate

watch_symbol

Pre-warm a live subscription (optional)

get_watched_symbols

Active subscriptions + buffer state

server_status

Health / diagnostics

Every market-data response includes source (websocket|rest), age_ms, and timestamp so the freshness is always provable.

Indicators (73)

  • MAs / overlays: sma ema wma smma dema tema hma vwma zlema alma kama trima lsma vidya t3 vwap vwapbands bbands donchian keltner supertrend ichimoku psar

  • Momentum: rsi stochrsi macd ppo stoch cci willr roc mom tsi ao cmo uo dpo trix coppock kst fisher rvi mfi wavetrend squeeze qqe crsi stc elderray zscore linregslope

  • Volatility: atr natr stdev hv chop ulcer massindex

  • Volume: obv adl cmf chaikinosc eom fi pvt vo klinger

  • Trend: adx dmi aroon vortex

  • Structure: heikinashi pivots

Specs are "name:p1,p2" and also accept Pine Script syntax — ta.rsi(14), ta.ema(20), ta.wt(10,21), ta.sqz — so TradingView users can paste familiar expressions. Derived signals include overbought-oversold state, MACD/PPO/WaveTrend/QQE cross, zero-line cross for oscillators, Supertrend/PSAR direction & flip, squeeze on/off, DMI/Heikin-Ashi trend, and Ichimoku cloud position. Includes crypto/Pine favorites (WaveTrend, TTM Squeeze, QQE, Connors RSI, Schaff Trend Cycle, VIDYA, T3). Adding a new indicator is a one-line REGISTRY declaration.

Structure recognition

On top of numeric indicators, Tickscope describes what the chart is doing: detect_patterns names candlestick patterns (engulfing, hammer/hanging man, doji family, morning/evening star, three soldiers/crows, …) with their bias; analyze_structure returns swing highs/lows labeled HH/HL/LH/LL, the inferred trend, and Break-of-Structure / Change-of-Character events (SMC-style); find_support_resistance clusters swing pivots into support/resistance zones with touch counts. These give an agent the vocabulary to describe a chart the way a trader would.

Deep analysis

deep_analyze answers a question about a symbol in one call, instead of making the agent chain a dozen tools. It returns:

  • Multi-timeframe trend confluence — the same symbol read across a 1d/4h/1h ladder, with whether the timeframes agree or conflict.

  • Market-state context — where price sits in its recent range (percentile), the trend state (trending_up / trending_down / ranging, from ADX + Kaufman efficiency ratio), and the volatility state (from ATR percentile), so a bare "RSI 30" reads against the conditions it showed up in.

  • Historical signal performance — for the current divergence, the forward-return distribution of every past confirmed occurrence on this symbol/timeframe (count, win rate, median). A strictly causal event study — no look-ahead, no repaint.

  • A synthesized verdict — bias, confidence, timeframe agreement, the execution-timeframe market state, and explicit caveats, all computed deterministically in Python so the call never hinges on the model eyeballing raw numbers.

compute_indicators now carries the same market-state context inline (it's ~free), and signal history is memoized per closed bar, so warm reads stay fast. Clients that support MCP prompts expose this as a slash command — /mcp__tickscope__deep_analyze (symbol + timeframe) — to trigger a full read on demand.

Resources

Supporting clients can also read live state as MCP resources: tickscope://status, tickscope://watched, and the template tickscope://ticker/{exchange}/{symbol}.

Example prompts

  • "What's BTC/USDT trading at on Binance right now, and the 24h change?"

  • "Should I care about this SOL/USDT setup? Do a deep, multi-timeframe read."

  • "Is there an RSI divergence on BTC/USDT 4h — and how has that signal performed on this pair before?"

  • "Screen the top 50 USDT pairs by volume for ones with RSI below 30."

  • "Map the key support/resistance on ETH/USDT 4h and tell me if the structure just broke (BOS/CHoCH)."

  • "What's the perpetual funding rate for BTC on Bybit right now — is it overheated?"

  • "Compare BTC/USDT across Binance, Bybit and OKX and show the arbitrage spread."

See examples/demo_prompts.md for a fuller recipe book (deep analysis, signal backtests, screening, monitoring, strategy checks).

Configuration

All settings are environment variables (see .env.example):

Variable

Default

Description

TICKSCOPE_EXCHANGES

binance,bybit,okx

Enabled exchanges (comma-separated)

TICKSCOPE_DEFAULT_EXCHANGE

binance

Default when exchange is omitted

TICKSCOPE_MAX_WATCHED_SYMBOLS

25

Max concurrent WS subscriptions (LRU evicted)

TICKSCOPE_RING_BUFFER_SIZE

1000

Per-symbol trade buffer size

TICKSCOPE_OHLCV_CACHE_PATH

~/.tickscope/ohlcv.duckdb

DuckDB cache file

TICKSCOPE_OHLCV_CACHE_TTL_S

60

Freshness window for the newest candle

TICKSCOPE_REST_RETRIES

3

Retry attempts for transient REST errors (rate limit / network)

TICKSCOPE_SCREEN_CONCURRENCY

5

Max concurrent symbols during screening/aggregation

TICKSCOPE_TRANSPORT

stdio

stdio or http

TICKSCOPE_LOG_LEVEL

INFO

Log level

Development

uv venv && uv pip install -e ".[dev]"
pytest                # ~100 unit + MCP-integration tests (live excluded)
pytest -m live        # live exchange tests (Binance/Bybit/OKX, run locally)
ruff check . && mypy  # lint + type gates

Tests cover indicator math against reference values, service cache/auto-watch logic, the full MCP tool path (tests/test_mcp_integration.py calls tools through mcp.call_tool), price-structure recognition, and a live suite that exercises the whole stack against real exchanges. See CONTRIBUTING.md for the project layout and contribution flow.

Roadmap

  • Pine Script-style indicator mapping (ta.rsi, ta.crossover, …)

  • 73 indicators + candlestick patterns + market structure (BOS/CHoCH)

  • Multi-exchange aggregation (weighted price / spread)

  • MCP resource push for watched symbols

  • Anchored / session VWAP

  • More exchanges (Kraken, Bitget, Gate, …)

  • Agent Skill (SKILL.md) wrapper

Contributing

Issues and PRs welcome — see CONTRIBUTING.md and our Code of Conduct. Keep dependencies minimal and the v1 scope read-only (public data, no order execution, no API secrets).

License

MIT © Tickscope contributors.

Disclaimer

This tool is for educational and research purposes only. It is not financial, investment, or trading advice. Market data may be delayed, incomplete, or inaccurate; do not rely on it for real trading decisions. Respect each exchange's terms of service and rate limits. See SECURITY.md.

Available Tools

19 tools
analyze_structureA

Analyze market structure: swing highs/lows, trend, BOS / CHoCH.

Builds an alternating swing sequence from confirmed pivots, labels each as HH/HL/LH/LL, infers trend (uptrend/downtrend/range), and reports whether the latest bar broke the most recent swing as a Break of Structure (continuation) or Change of Character (reversal). left/ right set the pivot confirmation window.

Inputs: symbol (required), left, limit, right, +2 more. Returns: object

compute_indicatorsA

Compute technical indicators for a symbol/timeframe.

indicators is a list of specs "name:param1,param2", e.g. ["rsi:14", "macd:12,26,9", "ema:20", "bbands:20,2", "supertrend:10,3", "stochrsi", "ichimoku"]. Pine-style aliases like "ta.rsi(14)" and "ta.ema(20)" are also accepted.

Supported (73):

  • MAs/overlays: sma, ema, wma, smma, dema, tema, hma, vwma, zlema, alma, kama, trima, lsma, vidya, t3, vwap, vwapbands, bbands, donchian, keltner, supertrend, ichimoku, psar

  • Momentum: rsi, stochrsi, macd, ppo, stoch, cci, willr, roc, mom, tsi, ao, cmo, uo, dpo, trix, coppock, kst, fisher, rvi, mfi, wavetrend, squeeze, qqe, crsi, stc, elderray, zscore, linregslope

  • Volatility: atr, natr, stdev, hv, chop, ulcer, massindex

  • Volume: obv, adl, cmf, chaikinosc, eom, fi, pvt, vo, klinger

  • Trend: adx, dmi, aroon, vortex

  • Structure: heikinashi, pivots

Returns each indicator's latest value(s) plus derived signals: RSI/MFI/ StochRSI/UO/CRSI/STC overbought-oversold state; MACD/PPO/WaveTrend/ QQE cross; zero-line cross for oscillators (ao/tsi/cmo/trix/ roc/mom/zscore); supertrend/psar direction & flip; squeeze on/off; dmi/heikinashi trend; ichimoku cloud signal. Set include_series=true for each indicator's primary time series. Pine aliases include ta.wt, ta.sqz, ta.ha.

Inputs: symbol (required), indicators (required), limit, exchange, +2 more. Returns: object

deep_analyzeA

Thorough, evidence-backed read of one symbol across multiple timeframes.

Returns, in a single call:

  • per-timeframe trend (HH/HL structure, BOS/CHoCH) and momentum,

  • statistical & market-state context (price percentile, ADX/efficiency trend state, ATR volatility state) so each value is interpretable,

  • the historical forward-return distribution of the current divergence signal on this symbol/timeframe — a strictly causal event study,

  • a synthesized verdict: bias, confidence, multi-timeframe agreement and explicit caveats.

Prefer this over the lighter compute_indicators / analyze_structure / detect_divergence when the user wants a thorough judgement, asks whether a setup is worth taking, or says "analyze X deeply". It is heavier (reads several timeframes + runs an event study), so use the single-shot tools for quick one-value questions.

timeframes defaults to a 1d/4h/1h ladder (highest -> execution). Read-only public market data; not financial advice.

Inputs: symbol (required), horizon, exchange, oscillator, +1 more. Returns: object

detect_crossA

Pine-style crossover analysis (ta.crossover/ta.crossunder).

series_a and series_b are each an indicator spec (ema:20, ta.sma(50)), a price source (close, hl2, …) or a numeric constant ("30"). Example: a golden cross is series_a="ema:50", series_b="ema:200". Returns the latest values, their relation, whether a cross happened on the last bar, and how many bars since the last cross.

Inputs: symbol (required), series_a (required), series_b (required), limit, +2 more. Returns: object

detect_divergenceA

Detect regular/hidden bullish & bearish divergence between price and an oscillator.

Compares the two most recent confirmed pivot highs (for bearish) and pivot lows (for bullish). oscillator is any indicator spec (rsi:14, macd:12,26,9, cci:20, mfi:14, …). left and right set the pivot confirmation window. Returns the detected divergences with their pivot price/oscillator values and bar offsets.

Inputs: symbol (required), left, limit, right, +3 more. Returns: object

detect_patternsA

Detect candlestick patterns on the most recent lookback candles.

Recognizes doji (incl. dragonfly/gravestone), hammer/hanging man, inverted hammer/shooting star, marubozu, spinning top, bullish/bearish engulfing & harami, piercing line, dark cloud cover, tweezers, morning/ evening star, and three white soldiers/black crows. Each result carries its conventional bias (bullish/bearish/neutral) and bars_ago.

Inputs: symbol (required), limit, exchange, lookback, +1 more. Returns: object

find_support_resistanceA

Find clustered support/resistance zones from swing pivots.

Groups pivot highs/lows that lie within tolerance_pct of each other into zones; each zone's touches is its strength. Returns the nearest support (below price) and resistance (above price) zones with their distance from the current price.

Inputs: symbol (required), limit, exchange, timeframe, +2 more. Returns: object

get_aggregated_priceA

Aggregate a symbol's price across multiple exchanges (arbitrage view).

Fetches the ticker on each configured (or given) exchange concurrently and returns the 24h-volume-weighted average price, the simple mean, the cheapest/most-expensive venue, and the cross-exchange spread (arb_spread / arb_spread_pct) — the foundation for spotting arbitrage. Venues that fail or lack the symbol are skipped.

Inputs: symbol (required), exchanges. Returns: object

get_funding_rateA

Get the current (and predicted) funding rate for a perpetual future.

Symbol should be a perpetual (e.g. BTC/USDT:USDT). Returns a structured error if the exchange does not support funding rates.

Inputs: symbol (required), exchange. Returns: object

get_ohlcvA

Get historical OHLCV candles (basis for charts and indicators).

Served from a DuckDB cache first, topping up only the missing tail via REST. timeframe accepts values like 1m,5m,15m,1h,4h,1d; since accepts ISO-8601 or epoch-ms. limit is capped at 1000.

Inputs: symbol (required), limit, since, exchange, +1 more. Returns: object

get_orderbookA

Get the current order book snapshot with computed spread.

Returns top-depth bids/asks (capped at 100), spread and spread_pct, plus freshness fields. Uses the live WebSocket buffer when warm, otherwise REST.

Inputs: symbol (required), depth, exchange. Returns: object

get_recent_tradesA

Get the most recent executed trades (ticks) from the live buffer.

Falls back to a REST snapshot (and starts watching) when the buffer is cold. limit is capped at 1000.

Inputs: symbol (required), limit, exchange. Returns: object

get_tickerA

Get the current price snapshot for a symbol (the primary quote tool).

Returns last/bid/ask, 24h high/low/volume, 24h change %, plus freshness fields source (websocket|rest), age_ms and timestamp. The first (cold) call answers via REST and starts a live WebSocket watch, so subsequent calls return fresher websocket-sourced data.

Inputs: symbol (required), exchange. Returns: object

get_watched_symbolsA

List currently active WebSocket subscriptions and their buffer state (diagnostic): channels, buffer size, last update and staleness.

Inputs: no named parameters. Returns: object

list_exchangesA

List the exchanges this server is configured to use.

Returns the configured exchange ids and the default one used when a tool call omits the exchange argument.

Inputs: no named parameters. Returns: object

list_symbolsA

List tradable symbols on an exchange, optionally filtered.

Use to discover valid symbols before other calls. quote filters by quote currency (e.g. USDT); search is a case-insensitive substring match (e.g. BTC).

Inputs: limit, quote, search, exchange. Returns: object

screen_marketA

Screen many symbols by indicator and price conditions.

filters is a list of conditions, each either indicator- or metric-based, e.g. [{"indicator":"rsi:14","op":"<","value":30}, {"metric":"change_24h_pct","op":">","value":5}]. op is one of < <= > >= == !=.

When symbols is omitted, the top top_n symbols by 24h volume for the given quote currency are screened. Runs with bounded concurrency to respect rate limits; per-symbol failures are returned in errors.

Inputs: filters (required), quote, top_n, sort_by, +3 more. Returns: object

server_statusB

Health and diagnostics: uptime, exchanges, watch count, cache rows, ccxt version, and WebSocket reconnect count.

Inputs: no named parameters. Returns: object

watch_symbolA

Pre-warm a live WebSocket subscription for a symbol (optional).

Most tools auto-watch on first use, so this is only needed to warm a buffer ahead of time. channels defaults to ["ticker","trades"]; valid channels are ticker, trades, orderbook, and ohlcv. For ohlcv, suffix the timeframe so the forming candle overlays your get_ohlcv queries on that timeframe — e.g. "ohlcv:1h" to enrich 1h candles (a bare "ohlcv" defaults to 1m and only overlays 1m queries). When the watch cap is exceeded, the least-recently-used symbol is released.

Inputs: symbol (required), channels, exchange. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 19 tools

    Disambiguation5/5

    Each tool targets a distinct aspect of market data or analysis: price snapshots, trades, candles, order book, funding, indicators, patterns, structure, etc. Overlapping analysis tools (compute_indicators, detect_divergence, detect_cross, etc.) have clear, specialized purposes and are well-differentiated by their descriptions.

    Naming Consistency4/5

    Most tools follow a verb_noun pattern (get_, list_, detect_, analyze_, find_, watch_, compute_, screen_). The style is uniformly lowercase with underscores, but a few names like 'server_status' and 'deep_analyze' deviate from the strict verb-first structure, making the pattern slightly less consistent.

    Tool Count4/5

    With 19 tools, this server is on the heavier side, but the broad scope of real-time market data, technical analysis, screening, and diagnostics justifies the count. Each tool serves a distinct purpose without feeling redundant, though a few analysis tools could theoretically be merged.

    Completeness5/5

    The tool set comprehensively covers the read-only market data and technical analysis domain: data retrieval (ticker, trades, OHLCV, orderbook, funding), symbol/exchange discovery, indicator computation, pattern/structure/divergence detection, screening, multi-exchange aggregation, and deep analysis. No significant gaps are apparent for its stated purpose.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • -
      license
      Not graded
      quality
      Not graded
      maintenance
      Real-time financial market data MCP server. Stocks, crypto, technicals, sentiment, FDA calendar. No API keys required.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      A comprehensive MCP service for cryptocurrency data acquisition with advanced technical analysis capabilities, supporting 100+ exchanges, 158 TA-Lib indicators, and dual transport protocols (stdio and HTTP/SSE).
      36 PyPI
      5
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Unified real-time & historical market data API for Forex, stocks (US/HK/A-share), crypto, indices & precious metals. Tick, order book depth & K-line via REST + WebSocket. AI-native: MCP server, Skill & CLI.
      918
      MIT