tickscope-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@tickscope-mcp what's the current BTC/USDT price?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Tickscope MCP
Real-time, free crypto market data for any AI agent — via MCP.

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 4hA 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-mcpRegister 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 |
| Configured exchanges + default |
| Tradable symbols (filter by quote/search) |
| Current price snapshot (primary quote tool) |
| Recent executed trades from the live buffer |
| Historical candles (DuckDB-cached) |
| Order book snapshot + spread |
| 73 indicators (RSI/MACD/Supertrend/WaveTrend/Squeeze/…) with derived signals |
| Regular/hidden bullish & bearish divergence (price vs oscillator) |
| Pine-style |
| Candlestick patterns (engulfing, hammer, stars, …) with bias |
| Market structure: swings, trend, BOS / CHoCH |
| Clustered support/resistance zones from pivots |
| Multi-timeframe read: trend confluence + market-state context + historical signal performance, with a synthesized verdict |
| Scan many symbols by indicator/price filters |
| Volume-weighted price + cross-exchange spread (arbitrage) |
| Perpetual funding rate |
| Pre-warm a live subscription (optional) |
| Active subscriptions + buffer state |
| 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 psarMomentum:
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 linregslopeVolatility:
atr natr stdev hv chop ulcer massindexVolume:
obv adl cmf chaikinosc eom fi pvt vo klingerTrend:
adx dmi aroon vortexStructure:
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 |
|
| Enabled exchanges (comma-separated) |
|
| Default when |
|
| Max concurrent WS subscriptions (LRU evicted) |
|
| Per-symbol trade buffer size |
|
| DuckDB cache file |
|
| Freshness window for the newest candle |
|
| Retry attempts for transient REST errors (rate limit / network) |
|
| Max concurrent symbols during screening/aggregation |
|
|
|
|
| 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 gatesTests 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 toolsanalyze_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
Scored across 19 tools
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.
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.
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.
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
Related MCP Connectors
Real-time crypto market data: candles, tickers, orderbooks across 13+ exchanges via MCP.
Crypto MCP with 21 tools for market data, DeFi, analytics, and sentiment. Post-paid USDC billing.
Trade 16 crypto exchanges + MetaTrader 5 from your AI assistant via one MCP connection.
Market Data App MCP — wraps the Market Data App API (marketdata.app)
Related MCP Servers
- -licenseNot gradedqualityNot gradedmaintenanceReal-time financial market data MCP server. Stocks, crypto, technicals, sentiment, FDA calendar. No API keys required.-
- AlicenseNot gradedqualityDmaintenanceA 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 PyPI5MIT

TickDB MCPofficial
AlicenseNot gradedqualityBmaintenanceUnified 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.918MIT- AlicenseNot gradedqualityDmaintenanceProvides live cryptocurrency market data including current prices, 24h stats, and top movers, accessible via MCP with a pay-per-call model.MIT