MCP Server

The Sharpe MCP Server exposes 43 tools (40 endpoint tools + 3 composite workflows), 4 resources, and 2 prompts for crypto derivatives and market data via the Model Context Protocol. It connects AI agents in Claude Desktop, Claude Code, Cursor, and any MCP-compatible client to data across 32 funding-rate exchanges and the rest of the Sharpe API surface: funding rates, futures, arbitrage, screeners, narratives, ecosystems, memecoins, new listings, project dashboards, and more.

Installation

Hosted endpoint (no install)

The same server is hosted at https://www.sharpe.ai/api/mcp over the Streamable HTTP transport. Clients that take a URL connect with nothing to install. Without a key the tools read the free public endpoints; send your key as an Authorization: Bearer sk_live_... header to use the authenticated /v1 routes and your plan's limits. Keyless calls to the hosted endpoint are limited per client to 60 calls a minute, and a JSON-RPC batch carries at most 10 messages.

claude mcp add --transport http sharpe https://www.sharpe.ai/api/mcp \
  --header "Authorization: Bearer sk_live_your_key_here"

{
  "mcpServers": {
    "sharpe": {
      "url": "https://www.sharpe.ai/api/mcp",
      "headers": { "Authorization": "Bearer sk_live_your_key_here" }
    }
  }
}

In Claude.ai or ChatGPT, add a custom connector with the URL https://www.sharpe.ai/api/mcp. Those connectors send no key, so the three key-only tools (get_token_scanner, get_stablecoins, get_derivatives_overview) return an error there; every other tool works.

npm package (stdio)

The published server is the npm package @sharpe-terminal/mcp-server. npx downloads the current npm release and runs it over stdio without a global install.

npx -y @sharpe-terminal/mcp-server

npm install --global @sharpe-terminal/mcp-server
sharpe-mcp

Configuration

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "sharpe": {
      "command": "npx",
      "args": ["-y", "@sharpe-terminal/mcp-server"],
      "env": {
        "SHARPE_API_KEY": "sk_live_your_key_here"
      }
    }
  }
}

Claude Code

claude mcp add sharpe -- npx -y @sharpe-terminal/mcp-server

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "sharpe": {
      "command": "npx",
      "args": ["-y", "@sharpe-terminal/mcp-server"],
      "env": {
        "SHARPE_API_KEY": "sk_live_your_key_here"
      }
    }
  }
}

Tools

The server exposes 43 tools organized into 8 categories. All tools accept optional parameters with sensible defaults and return structured data.

Tool behavior

All Sharpe MCP tools are read-only market-data calls. Tools advertise MCP annotations for readOnlyHint, destructiveHint=false, idempotentHint, and openWorldHint so compatible clients can classify them safely.

The 40 endpoint tools are generated from the API's contracts: each tool's name, description and parameters (types, enums, bounds, defaults) are the ones the API documents, and the npm server, the hosted endpoint and the Python server serve the same definitions. An argument a tool does not take, or one outside its schema, is refused with every issue named (Invalid arguments for get_funding_rates: "limit" must be >= 1) rather than dropped. The Python server spells multi-word parameters in snake_case (min_oi_usd for the API's minOiUsd); the TypeScript server and the hosted endpoint use the API's names.

An endpoint tool answers structuredContent of { "data": ..., "meta": ... }, with pagination beside data when the answer is one page, and the same JSON as text for clients that read only the content array:

• data is the payload as the API served it: the /v1 route's data with an API key, the free route's body without one. Where a free route answers in its own shape, data is that shape. Tools do not declare an MCP outputSchema yet.
• pagination is { cursor, has_more, total }: pass cursor back to read the next page.
• meta.route says which route answered (v1 or public); meta.as_of, stale_after, freshness_status and runtime_status carry the freshness the API reported, and meta.warnings what it (or the client) could not do. Treat freshness_status stale or unknown and runtime_status degraded as caveats to state.

Composite workflow tools return { "report": "..." } in structuredContent plus the same formatted markdown in text content. A failed call returns isError with the reason as text.

Large list responses are capped at 200 rows, and a payload still over about 25,000 characters has its largest arrays halved until it fits. A time series ordered oldest first keeps its newest rows; every other list keeps its head, where the API puts its ranking. The payload keeps its shape; the cut is reported in meta: truncated: true, a truncation_message, and truncated_fields, which maps each cut field (by its path in data, e.g. data.rows) to { total, showing }, plus kept: "latest" when the newest rows were the ones kept. Where a tool takes limit and cursor, page with them rather than relying on the notice.

Composite tools

High-level tools that combine multiple API calls into a single consolidated response. Best for broad questions. Each report is composed and rendered on the server by its own endpoint (/v1/coins/{coin}/analysis, /v1/briefing and /v1/opportunities, with keyless twins under /api; see Reports), and the tool prints the endpoint's report_md as served: the TypeScript server, the Python server and sharpe briefing print the same bytes. Every number a report prints is a field the API serves, the same value the web page and /api/v1 give: rankings, floors, averages and APRs are request parameters and response fields, never recomputed. Each report ends with a Data freshness line naming the freshness of every answer it read (dataset, as_of, status, and degraded with the API's warnings when a read was degraded); a read that failed is named on a Data gaps line, and the call fails only when every read did.

analyze_coin

Single-coin analysis in one view. Best tool for "what's happening with BTC?" questions. It combines:

• the price-prediction score and every signal, matched in the coverage list by the asset the funding read resolved (bitcoin is BTC, 1000PEPE is PEPE), else by exact ticker (a coin outside it says so rather than guessing a slug); the price is the prediction snapshot's, printed with its as-of (it refreshes on a 12-hour SLA);
• current funding for the coin's ten largest markets by open interest (get_funding_rates with sort=-open_interest): each market's rate_8h, apr and open interest as served, lot contracts included, labelled with its rate_kind: on most venues the rate is the estimate of the next payment, not yet charged; on Kraken, Crypto.com and Bitfinex it is the last settled rate;
• the coin's average and median funding across venues on the 8-hour basis (summary=1: the funding grid's Avg Rate, open-interest-weighted or its median, with the venues behind it), over those same rates, so estimates and last-settled rates mixed;
• the asset's open-interest total in USD notional, venue count and the 1h/24h change of that USD total, from its row on the global board (get_global_overview: every contract of the asset once, lots included, venues listed in openInterestExcludedVenues left out and named, MEXC today), printed beside the asset's 24h price change because USD open interest moves with price;
• the estimated dollar funding over the next 24 hours at current rates, for each row the settlement API returns for the coin, with its rate_source. The settlement read matches the ticker as written, so when the funding read holds contract spellings it does not (PEPE and KPEPE for 1000PEPE, BTC for bitcoin), the report names them as not in the figure.

market_briefing

Market briefing combining the market overview, top and worst narratives, funding rate highlights, and the estimated whole-market funding settlement. Best tool for "what's going on in crypto?" or morning briefings.

No parameters. Returns formatted text with market stats (BTC dominance from btc_dominance_pct), Fear and Greed, the API's narrative ranking by 24h change (sort, top, bottom: a narrative without a 24h change is never ranked), and the API's funding extremes (get_funding_rates with extremes=3 and min_oi_usd=1000000): the highest (at or above zero) and lowest (below zero, so possibly none) markets by 8-hour-equivalent rate among fresh markets with a usable interval and at least $1M of open interest, printed as APR with the 8h and raw rates and each venue's rate_kind (mostly the estimate of the next payment, not yet charged), plus the counts the API left out.

find_opportunities

Scans all exchanges for funding arbitrage, combining spot-perp basis trades and cross-exchange funding arb.

No parameters. Spot-perp rows come from the board with minOiUsd=1000000 (perp legs with at least $1M of open interest, unknown fails) in the API's order, net APR first, each with its perp open interest, executionStatus, and a flag when pairStatus is not eligible or fundingIsStale is true; the report says how many of the board's rows are executable, and marks open interest on a venue the API leaves out of its cross-venue totals (MEXC today) as unverified, since the floor still counts it. Cross-exchange rows need at least $1M of open interest and 24h volume on both legs and keep the board's order (executable rows first by net APR, then indicative rows by net APR where they have one, else gross APR; limit=10); each prints its funding spread (netFundingRate per intervalHours) and its entry gap (spreadRate, the price gap paid to open both legs, negative = favourable). The funding summary is the API's market stats (stats=1): mean and open-interest-weighted funding APR over the fresh primary contract of every venue and asset, and the positive/negative counts.

Derivatives tools

Granular derivatives data for funding rates and futures charts.

get_funding_rates

Perpetual funding rates across 32 funding-rate exchanges (Binance, Bybit, OKX, Gate.io, Hyperliquid, Kraken, Aster, Lighter, dYdX, and more; read sharpe://exchanges for the current list). Positive rate means longs pay shorts.

rate is a decimal fraction settled over that row's own interval_hours (1h, 2h, 4h, 8h or 24h depending on venue and market). It is not a percent and never implicitly 8h: current rows also carry rate_8h (rate * 8 / interval_hours) and apr (rate * 8760 / interval_hours), null without a usable interval, so compare venues on those.

With type='current' the API can answer with aggregates instead of rows: extremes (the highest markets by rate_8h among those at or above zero and the lowest among those below zero, so either list can be empty), stats (the whole book's funding APR) and summary (a coin's average and median funding across venues).

coin names an asset: PEPE returns every PEPE contract, the 1000PEPE and KPEPE lot contracts included. Current and accumulated rows carry asset_id, asset_symbol, lot_multiplier, instrument_status and is_live (null = unknown).

Accumulated rows also carry coverage: per window (1d, 7d, 30d, 90d, 1y), the share of the span the contract was expected to settle in that its settlements cover (coverage_ratio, null when it was not expected in the window at all), complete (at least 90%), and whether it was listed or halted inside the window. Compare acc_* across contracts only on complete windows.

get_funding_settlement

Dollar value of funding actually paid at each settlement -- not just the rate -- and which side, longs or shorts, paid it. Every response carries both the per-coin row breakdown and a totals block (net/long_paid/short_paid) for the requested window and class, so "who paid funding today" reads directly from totals rather than being summed from a page of rows; totals always reflects the full requested class regardless of any coin/exchange filter on the rows.

window=current (the default) is the next 24 hours of funding at current rates -- each contract's forward rate × 24 / its own interval hours, priced live off open interest -- always estimated, never realised. 1d/3d/7d are realised windows; one whose coverage is below 90% carries partial: true (complete: false) in its window value because its history is still accruing, not a completed total, and halted_within_window: true says a contract stopped settling inside the window (listed_within_window is always null: no listing time is known). Sign convention: net = long_paid - short_paid; positive means longs paid more than they received (a cost to longs), negative means shorts paid more. Both long_paid and short_paid are always non-negative. Missing is null, never 0.

get_global_overview

The whole-market derivatives board in one call: total open interest with its crypto-versus-RWA split, 24h liquidations, average Wilder RSI(14) across the top 100 crypto perps by market cap, the Altcoin Season Index, open interest by asset class, and a ranked per-asset row table. Liquidations are crypto-only because no RWA perp venue publishes a liquidation feed.

get_rwa_perp_funding

Funding and carry for real-world-asset perpetuals (RWA perps: stocks, pre-IPO, ETFs, indices, commodities, FX) across 19 venues. Those venues are CEXs (Binance, Bybit, OKX, Bitget, Gate, Kraken, Coinbase), perp DEXs (Aster, Lighter, Extended, GRVT, ApeX, Pacifica, Orderly), Hyperliquid HIP-3 builder markets, and the borrow-based venues Ostium and Avantis. Rates are interval-true and mechanism-true; Ostium's both-sides rollover is reported as borrow_apr_annual, a cost that is never mixed into funding spreads.

get_futures_data

Time-series or snapshot data for 24 MCP/API futures chart types: open interest, liquidations, volume, long/short ratios, funding, basis, term structure, and signal views.

get_futures_coins

Lists up to 1,000 coins with futures data, including per-coin capability flags (hasFunding, hasOI, hasLiquidations, hasLongShort, hasCVD, hasBasis), venue coverage, and market-cap rank.

No parameters.

get_derivatives_overview

Market-wide derivatives snapshot: total OI, average funding rate, OI-weighted funding, top 20 coins by OI (each top_coins_oi entry is an asset, its lot spellings included), and exchange/coin counts.

No parameters.

Market data tools

Broad market data covering heatmaps, correlations, price predictions, and token discovery.

get_heatmap

Market heatmap data with tokens sized by market cap and colored by price performance. Aggregate narrative and ecosystem responses include explicit complete/partial coverage.

get_correlation_matrix

Pearson correlation matrix for crypto and TradFi assets over a given lookback period.

get_market_overview

BTC and ETH price/change, total crypto market cap and 24h volume, BTC dominance, total market-cap change, and the Fear and Greed Index. Auxiliary source fields are nullable when unavailable.

No parameters. Use this as the first call for any general market question.

get_price_prediction

Deterministic directional scores with sub-signal breakdowns for bias assessment (bullish/bearish/neutral, 0-100 consensus score, RSI, EMA trends, derivatives signals). Optional 7D/30D values are heuristic scenarios, not calibrated targets or probabilities.

search_market_cap

Search crypto and supported TradFi assets by name or ticker to find canonical asset IDs and nullable market stats.

get_gem_finder

Market-ranked token rows for valuation and momentum screening. Returns market cap, nullable FDV and FDV/MCap ratio, volume, nullable price changes, ATH history, preferred chain scope, observed exchange availability, and enrichment coverage. Ambiguous same-ticker assets do not receive symbol-only exchange attribution. It does not return wallet labels or a proprietary score.

get_stablecoins

Stablecoin overview, detail, and yield data including nominal supply at peg, marked value, nullable peg metrics, mechanism mix, chain supply, velocity coverage, freshness, and APY risk flags.

get_mindshare

Narrative mindshare rankings, token-level attention rows, rolling windows, and historical snapshots.

get_web_traffic

Attention rankings, social snapshots, and market-level signals for coins and narratives, plus CoinGecko trust-score rankings for exchanges.

Screener tools

Token-discovery workflows for token scanning and contract risk review.

get_token_scanner

Read-only scanner modes for hot tokens, new runners, alpha drops, AI tokens, and top-new pairs.

Responses include per-source coverage. Valuation and valuation-dependent risk fields remain null when the provider does not supply enough data.

get_rug_check_security

Token contract and liquidity risk signals for rug-check review, plus the Rug Check score the page shows, computed by the API (score.value 0-100, verdict, data_completeness, engine_version) with the checks behind it.

get_rug_check_trending

Trending tokens suitable for rug-check review.

get_insider_selling

Insider selling pressure signals across crypto assets, including wallet concentration, holder-quality risk, sell-side flow, and derivatives confirmation.

get_pump_dump

Pump-and-dump manipulation risk signals across crypto assets, including derivatives pressure, holder concentration, liquidity quality, DEX flow, and price behavior.

Arbitrage tools

get_arbitrage_spot_perp

Spot-perp funding-capture rows with live funding, verified spot or margin availability, diagnostic basis, gross APR, and net APR after the venue's taker fees, the adverse entry basis and a known borrow cost, in the board's order (executable rows first by net APR). Each row carries perpSymbol, perpOpenInterestUsd, fundingIsStale, executionStatus with indicativeReason, pairStatus, breakEvenDays, requiresBorrow / borrowCostIncluded, apr7d / carrySignFlip7d, fundingAsOf and per-leg price times. The whole board is about 2.4 MB, so the tool asks for a 100-row page unless given limit or cursor.

get_arbitrage_cross_exchange

Cross-exchange funding arbitrage across every funding venue, one row per asset (its best executable pair, else its largest gross differential), ranked with executable rows first by net APR, then indicative rows by net APR or gross annualized funding differential. Executable means a book-priced spread, legs within 5%, reported top-of-book depth of at least $10,000 and fresh quotes; otherwise indicativeReason says why. Net APR charges both venues' taker fees and the adverse entry spread, never crediting a favourable one; unknown market data is null, never zero. Each row carries pairStatus, breakEvenDays, roundTripFeeRate, the legs' symbols and intervals, fundingAsOf and per-leg price times.

get_arbitrage_dated_futures_basis

Spot-futures cash-and-carry scanner rows for buying spot and selling dated futures, ranked by net APR after 2 spot and 2 futures taker fills: rows at least 3 days from expiry first, executable rows first within them, then snapshot_quote rows (executable on a live read). indicativeReason names why a row is not executable.

get_arbitrage_futures_calendar_spread

Near-versus-far dated futures curve scanner rows with forward yield and net roll APY after 4 futures and 2 spot taker fills; direction and curve come from mark (else mid) prices. Pairs with a near leg under 3 days or a gap under 7 days (belowTenorFloor) rank last.

get_arbitrage_perp_dated_carry

Perp funding versus dated futures carry rows: the dated contract's basis against the perp (not spot) at the trade's executable sides, against the funding expected to expiry from the 7-day realised average (fundingProjection). Rows carry direction and crossVenue (the legs usually sit on two venues with separate collateral); funding7dStabilityPct is a deprecated alias of funding7dCumulativePct.

get_arbitrage_cex_spot_transfer

CEX spot-transfer routes after exact network matching, token-contract identity, withdrawal/deposit status and minimums, withdrawal fee, per-venue taker fees, depth and slippage. Routes netting above zero come first; up to 50 near misses follow as indicative below_fees. Books are judged on 60 seconds, networks on 10 minutes; meta.transferScan counts what the scan evaluated.

get_arbitrage_borrow_rates

Spot-margin borrow rates per coin across Binance, OKX, Bybit and Gate.io, the venues that publish them without an account. One row per coin with every venue's quote cheapest first: hourlyRate (fraction per hour) and annualRate (hourlyRate × 8,760, simple). A venue that does not price a coin is absent, never 0; venues reports each venue's status (ok, stale, failed, unsupported).

get_arbitrage_funding_spread_history

A pair's historical funding spread and carry backtest from stored settlements: a spot-perp carry on one venue, or a long and a short perp across venues. Legs are aligned by settlement time with each contract's real interval (never an assumed 8h); series carries spreadApr, legAprs, cashflow and cumulativeCarry, and backtests the 1, 7, 14, 30 and 60-day windows below days plus days itself: fundingCollected, fees (entry and exit taker fills at each venue's standard rate), netReturn, grossApr, netApr, negativeCarryDays, maxDrawdown, breakEvenDays, coverageRatio. All fractions.

get_arbitrage_fixed_floating_funding

Pendle Boros fixed vs floating funding: every live Boros market (a venue's perp to a maturity: Binance, OKX, Bybit, Gate, KuCoin, Hyperliquid incl. the xyz dex, Lighter) with impliedApr (Boros's fixed rate), floatingApr (the venue's current funding as Boros reports it), realised7dApr and realised30dApr (Sharpe's stored funding for the same contract, acc × 365 / days) and spread7dApr / spread30dApr = implied − realised: positive means locking the fixed rate beats the floating leg. Fractions per year, gross of fees. A missing realised figure is null with realised7dNullReason / realised30dNullReason, never 0.

Category tools

Sector, chain, and memecoin narrative analytics.

get_narratives

Analytics for 30 MCP narrative slugs: L1, L2, DeFi, AI Agents, DePIN, RWA, Gaming, and more. Returns market cap, volume, performance, and social sentiment per narrative.

get_ecosystems

Analytics for 25 blockchain ecosystems: Ethereum, Solana, BNB Chain, Arbitrum, Base, and more. Returns market cap, volume, TVL, and performance per ecosystem.

get_memecoins

Memecoin narrative data across grouped categories: Dog, Cat, Frog, AI, Solana, Base, Pump.fun, and more. Returns market cap, market share, volume, freshness, calculation method, short-term momentum score, and top coins per category.

get_memecoin_launches

Recently launched memecoin pairs screened by age, liquidity, volume, and transaction count. This is a discovery feed, not a contract-security verdict.

get_news

Aggregated crypto news feed from multiple sources, ranked by reliability tier.

New listings tools

Listing lifecycle events across CEXs and Perp DEXs, tagged by narrative and source confidence. Use these as a forward signal for where exchange liquidity is being deployed.

get_exchange_listings

Aggregated hub payload: weekly + monthly listing counts by narrative and exchange, last 90 days of recent listings, and summary stats (WoW/MoM deltas, top narratives of the month, top exchanges of the month). Best tool for "which narratives are CEXs deploying listing slots toward?".

get_recent_listings

Flat feed of recent listings, one row per token-exchange pair. Event-filtered responses include last_updated_at, partial, and provider_coverage; agents should inspect these before treating a quiet feed as a market signal.

get_listing_events

Canonical listing event feed across spot, perp, futures, and options markets. Returns event type, instrument id, status, source URL, source confidence, real source-observation freshness, and per-provider health. generated_at is response assembly time; use last_updated_at for freshness.

get_listing_exchanges

Typed connector registry for supported listing venues, including market coverage, source docs, enabled status, polling group, and parser confidence.

System tools

get_api_coverage

Metadata about all available data products: supported exchanges, coins, chart types, timeframes, and update frequencies. Call this first to discover what data is available before making specific queries.

No parameters.

Resources

The server exposes 4 MCP resources that provide reference data for valid parameter values.

Prompts

The server includes 2 guided prompt templates that walk AI agents through multi-step analysis workflows.

market_analysis

Guides the agent through a 6-step market analysis: market overview, derivatives health, sector rotation, ecosystem flows, arbitrage opportunities, and synthesis into a bullish/bearish/neutral verdict.

No parameters.

coin_deep_dive

Guides the agent through an in-depth single-coin analysis: quick analysis, futures deep dive (OI, long/short, liquidations, basis), funding history, correlations, price prediction, and a final synthesis with key levels and risk factors.

Environment variables

Custom base URLs must use https://, except local development hosts such as http://localhost, http://127.0.0.1, and http://[::1]. The server refuses HTTP redirects from API calls so credentials are not forwarded to unexpected hosts.

Works without an API key

Without a key a tool reads the free route, and meta.route is public. Most free routes answer the same data as /v1; a few answer in their own shape (the scanners, settlement and the signal tools among them). Four free routes ignore limit and cursor (get_global_overview, get_rwa_perp_funding, get_futures_data and get_gem_finder); the server pages their rows itself with the same cursor /v1 uses, so a keyless caller still reaches every row. A parameter a free route does not read is named in meta.warnings.

When a page is larger than the context-window cap, the tool keeps the rows that fit and points pagination.cursor at the first row it left out, so following the cursor skips nothing. get_funding_rates, get_gem_finder and get_arbitrage_spot_perp ask for a 25-row page when the call names none.

Get an API key

Create a key from the API key dashboard, then set it as SHARPE_API_KEY in your MCP client configuration. The full key is shown once at creation time.

Example prompts

These natural language prompts show how AI agents route to the correct tools.