API key required
Every tool needs an API key from a paid plan, on the hosted endpoint and in the npm package. It is the same key the REST API uses, and tool calls draw on the plan’s monthly quota and per-minute limit (see Rate limits). A key without an active plan answersexpired_api_key.
Subscribe at /dashboard/billing, create the key at /dashboard/api-keys,
then send it as an Authorization: Bearer sk_live_... header (hosted) or set SHARPE_API_KEY (npm). A client that
connects by URL alone signs in instead (Sign in from a connector), and its calls use the
account’s key.
The hosted endpoint answers a request that carries neither a key nor a sign-in with HTTP 401 and the sign-in
challenge. The npm package lists its tools, resources and prompts without a key; a tool call without one answers how
to get one.
Installation
Hosted endpoint (no install)
The same server is hosted athttps://www.sharpe.ai/api/mcp over the
Streamable HTTP transport. Clients that take a URL connect with nothing to
install. Send your key as an Authorization: Bearer sk_live_... header: every
tool reads the authenticated /v1 routes under your plan’s limits. A JSON-RPC
batch carries at most 10 messages.
Claude Code
Cursor (.cursor/mcp.json)
Sign in from a connector
A client that connects by URL alone, such as a Claude.ai or ChatGPT custom connector, needs no header: addhttps://www.sharpe.ai/api/mcp and the first
connection opens a Sharpe sign-in. Sign in with your email and approve access;
the connector’s tool calls then run as your account’s API key, under the same
plan, trial and limits as REST calls. Create the key first: a signed-in account
without one is answered with a link to create it.
One-click install
Both add the hosted server by its address. A client that supports MCP sign-in then signs you in; otherwise add your key as theAuthorization: Bearer header
in its MCP settings.
Codex
Gemini CLI
Agent skills
The Sharpe skills teach an agent which tool answers which question, how to report the data’s freshness, and how to set the server up. In Claude Code the plugin adds the hosted server and both skills; it asks for your API key when it is enabled.Claude Code plugin
Any agent that supports skills
/.well-known/agent-skills/index.json.
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. It needs Node.js 20 or later.
No install needed (recommended)
Persistent npm install
Command line
Given arguments, the same package runs one command instead of the server: one command per endpoint tool, with the tool’s parameters as flags and the API’s JSON answer on stdout. See the CLI section of Developer tools.One call from a shell
Configuration
Claude Desktop
Add to yourclaude_desktop_config.json:
Recommended (npm)
The
env block is required. Without SHARPE_API_KEY the server still starts
and lists its tools, and every tool call answers how to get a key.Claude Code
Add to Claude Code
Cursor
Add to.cursor/mcp.json:
Tools
The server exposes 42 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 forreadOnlyHint, destructiveHint=false, idempotentHint, and openWorldHint so compatible clients can classify them safely.
The 39 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 and the hosted endpoint 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. Both use the API’s parameter names (minOiUsd).
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:
datais the payload as the API served it: the/v1route’sdata.paginationis{ cursor, has_more, total }: passcursorback to read the next page.meta.as_of,stale_after,freshness_statusandruntime_statuscarry the freshness the API reported, andmeta.warningswhat it (or the client) could not do. Treatfreshness_statusstaleorunknownandruntime_statusdegradedas caveats to state.
tools/list declares it as the tool’s outputSchema (JSON Schema 2020-12, the MCP default), and a validating client checks each result against it. The other endpoint tools answer the same shape without a declared schema until a recorded /v1 answer proves theirs; tools/list shows which tools declare one.
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, see Reports), and the tool prints the endpoint’s report_md as served, byte for byte. 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 (
bitcoinis BTC,1000PEPEis 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_rateswithsort=-open_interest): each market’srate_8h,aprand open interest as served, lot contracts included, labelled with itsrate_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 inopenInterestExcludedVenuesleft 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 for1000PEPE, BTC forbitcoin), 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, the tracker’s btc_market_share), 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 35 funding-rate exchanges (Binance, Bybit, OKX, Gate.io,
Hyperliquid, Kraken, Aster, Lighter, edgeX, 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
how many tracked venues are live) and summary (a coin’s average and median funding across
venues, its open interest over every contract and its next settlement). With
type='accumulated', summary answers per window the coin’s median realised funding and
median APR over the venues whose history covers the window, and its carry spread APR (best
short venue minus best long venue).
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 carry each window’s APR (acc_apr_1d … acc_apr_1y: the sum annualised
over the days of history behind it) and 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 that were neither listed nor halted inside the window: those sum fewer hours than the window.
One of
current (live snapshot), accumulated (cumulative over
7d/30d/90d/1y), or history (per-coin time-series). Defaults to current.Coin ticker, lot spelling or full name (
BTC, PEPE, 1000PEPE, kPEPE,
bitcoin). Returns every contract of that asset, whatever its base_coin
spelling. Required when type='history'; optional for current and
accumulated, where the server filters rows to that asset before truncation.Filter to a single venue. Accepts the slug (
gate-io), the display name as
returned in the exchange field (Gate.io), or the ccxt id.Collateral convention:
linear for quote-margined contracts, inverse for
coin-margined ones. Unfiltered by default.One of
crypto, equity, commodity, fx, index. Unfiltered by default.
The funding book carries tokenized equity, commodity, index and FX perps
alongside crypto, because they trade on the same venues.Maximum rows per page, 1-5000. Page the full book with
limit + cursor
rather than relying on the truncation notice.type='current' only: open_interest or -open_interest orders the rows by
their open interest (unknown last either way) before limit/cursor.type='current' only, 1-100: answer with the N highest and N lowest markets by
rate_8h (extremes.highest, extremes.lowest) among fresh rows with a usable
interval: highest holds only rates at or above zero and lowest only rates below
zero, so either list can be shorter than N or empty. Also answers
extremes.omitted (stale, no_interval, below_floor). Returns an
object instead of rows; do not pass limit, cursor or sort with it.With
extremes only: the open-interest floor in USD. Unknown open interest fails a
floor above 0.type='current' only: 1 answers with market.funding_apr_mean,
market.funding_apr_oi_weighted, market.positive and market.negative for the
whole book. Cannot be combined with coin, exchange, margin, asset_class,
limit, cursor or sort.type='current' with coin only: 1 answers with one summary entry per
base_coin spelling and asset class: funding_avg_8h, funding_median_8h,
funding_method, funding_venues_used, funding_venues_stale, funding_all_stale.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.
One of
all, crypto, equity, commodity, fx, index (one asset
class each, as on the funding board) or rwa, every non-crypto class at
once. Defaults to all. The five classes’ totals, and crypto + rwa
totals, always equal the all totals.Filter rows to a single venue. Free-form and registry-driven; an
unresolvable value is rejected rather than silently returning an empty book.
Sort field for the selected
window: base_coin, net, long_paid,
short_paid or open_interest_usd, prefixed with - for descending. A row
with no value for the field (an unpriced coin) sorts last either way.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.
Universe to return rows for:
crypto (default), equity, preipo, etf,
index, commodity or fx. The metric block is identical on every tab.Rows per page, 1-1000. A paged response is
{ data, pagination } holding
only the ranked rows; the metric block comes back on unpaged calls.get_rwa_perp_funding
Funding and carry for real-world-asset perpetuals (RWA perps: stocks, pre-IPO, ETFs, indices, commodities, FX) across 13 venues. Those venues are CEXs (Binance, Bybit, OKX, Bitget, Gate, Kraken), perp DEXs (Aster, Lighter, Extended, GRVT, ApeX, Pacifica) and Hyperliquid’s HIP-3 builder markets. Rates are interval-true and mechanism-true.
One of
current (latest per-market snapshot), history (session-tagged
settlement time-series for one symbol; Hyperliquid + Kraken), or stats
(best carry, top cross-venue spread, weekend premium, open interest).
Defaults to current.Underlying equity ticker (e.g.
TSLA, NVDA, MSTR). Required when
type='history'. GOOG and GOOGL are distinct share classes.Filter to a single venue, e.g.
Binance, Bybit, OKX, Kraken,
Aster, Lighter, Pacifica, or the Hyperliquid HIP-3 builder market (Hyperliquid).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.
Rows per page, 1-10000, oldest first. Without
limit, long series keep
their newest rows and oi-snapshot returns each exchange’s latest reading.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: coins (a Top N universe, or one narrative’s or ecosystem’s members) or one tile per narrative or ecosystem, with price change (1h, 4h, 24h, 7d, 30d, 1y), funding APR, RSI(14), relative volume, open interest and OI value change (USD). Tiles are weighted baskets of every eligible member, with member coverage in constituents and the median member in median. Aggregate narrative and ecosystem responses include explicit complete/partial coverage.
Coins-mode universe, one of 39 ids:
top10, top20, top30, top50
(the default), 15 narratives (e.g. decentralized-finance-defi,
layer-1, meme-token) and 20 ecosystems (e.g. solana-ecosystem). The
legacy top-100 is an alias of top50. Ignored in the aggregate modes.Comma-separated CoinGecko coin ids to leave out (e.g.
bitcoin,ethereum).
Coins mode drops them after the Top N cut without refilling; the
aggregate modes rebuild every tile without them.get_correlation_matrix
Pearson correlation matrix for crypto and TradFi assets over a given lookback period.
Comma-separated asset IDs. Crypto uses canonical IDs (
bitcoin,
ethereum), TradFi uses short IDs (sp500, gold, nvda). Max 10.get_market_overview
BTC and ETH price and 24h return, total crypto market cap and 24h volume, BTC dominance (btc_market_share), the total market cap’s 24h return, and the Fear and Greed Index. Every return and share is a fraction. 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.
Keep only assets whose home chain is this chain (e.g.,
solana, base,
arbitrum). An asset matches its home chain (chainSlug) only, not
chains it is bridged to.
An unknown chain is a 400. Send the same chain with each cursor.Snapshot-bound cursor returned by the previous page. Restart without it after the cache refreshes and the cursor expires.
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
Contract and liquidity risk review for tokens.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.
One coin’s row by its CoinGecko id (e.g.,
bitcoin), exactly as the scorer
wrote it: score is null once the coin stopped qualifying. limit and
min_score do not apply to it.get_pump_dump
Pump-and-dump manipulation risk signals across crypto assets, including derivatives pressure, holder concentration, liquidity quality, DEX flow, and price behavior.
One coin’s row by its CoinGecko id (e.g.,
bitcoin), exactly as the scorer
wrote it: score is null once the coin stopped qualifying. limit,
min_score and phase do not apply to it.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.
Perpetual-leg direction:
all, short for positive funding capture, or
long for negative funding capture. Defaults to all.Minimum open interest in USD on the perp leg (
perpOpenInterestUsd). A row
whose open interest is unknown fails a floor above 0. Default 0 (no floor).Rows per page (1 to 1000), in board order. The tool sends
100 unless
limit or cursor is given.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.
Comma-separated venues to compare (e.g.,
Binance,Bybit,Hyperliquid).
Omit for every funding venue (a venue the instrument master marks not live
is skipped).Minimum open interest in USD on the smaller leg. Legs with unknown OI
fail the floor. Default 0 (no floor).
Minimum 24h volume in USD on the smaller leg. Legs with unknown volume
fail the floor. Default 0 (no floor).
Underlying filter:
all (default), crypto, or rwa (equity,
commodity, FX and index perps). Pairs never cross asset classes.Narrative filter:
all (default), memes, ai-agents, layer-1 or
defi. Keeps only crypto coins in that narrative’s CoinGecko category;
RWA perps are left out when a sector is set.At most this many rows, the first ones in the board’s order (executable
first). Default: every row.
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.
Minimum of the board’s net figure, as a fraction (
0.05 is 5%): netApr
(basis), netRollApy (calendar), netCarryApr (carry: the annualized net
carry, not the edge to expiry).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.
Minimum of the board’s net figure, as a fraction (
0.05 is 5%): netApr
(basis), netRollApy (calendar), netCarryApr (carry: the annualized net
carry, not the edge to expiry).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) and the 7-day cumulative funding as funding7dCumulative, a fraction.
Minimum of the board’s net figure, as a fraction (
0.05 is 5%): netApr
(basis), netRollApy (calendar), netCarryApr (carry: the annualized net
carry, not the edge to expiry).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.
Spot-perp perp contract symbol, e.g.
BTCUSDT. Optional: the venue’s
contract with the largest open interest otherwise.Spot-perp:
short (default, buy spot / short perp) or long (sell spot /
long perp; borrow interest not included).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. Each row also
carries the executable edge at the Boros quote, edge7dApr and edge30dApr
(the better of receiving fixed at the bid or paying it at the ask against
realised funding; edge30dSide names the side), Boros’s takerFeeApr and
settleFeeApr, and netEdge30dApr = edge30dApr − both fees. Rows rank by
netEdge30dApr, highest first: markets under 3 days to maturity rank last,
and a market without a net edge (no quote, realised figure or fee) ranks after
those with one. Ties fall to the 7-day net edge, then impliedApr, then marketId.
Optional venue: Boros’s name (
Binance, OKX, Hyperliquid, Gate,
Kucoin, Lighter, Bybit) or Sharpe’s (Gate.io, KuCoin,
tradeXYZ).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.
Narrative slug for detail view (e.g.,
defi, ai-agents, rwa,
layer-1). See sharpe://narratives resource for all 30 MCP slugs. Omit
for overview of all.Order the list by 24h return:
-return24h (highest first) or return24h.
A narrative without a 24h return comes last either way.Adds
top: the N narratives with the highest 24h change (1-50). A narrative
without a 24h change is never ranked.get_ecosystems
Analytics for 25 blockchain ecosystems: Ethereum, Solana, BNB Chain, Arbitrum, Base, and more. Returns market cap, volume, TVL, and performance per ecosystem.
Ecosystem slug (e.g.,
ethereum, solana, arbitrum, base). See
sharpe://ecosystems resource for all 25 slugs. Omit for overview.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.
Memecoin narrative slug (e.g.,
dog-coins, cat-coins, frog-coins,
ai-memes, trump-coins). Omit for all.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.
Comma-separated chain ids. Default
solana,bsc, the chains with a recognised meme launchpad; other chains return no rows yet.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?”.
Filter to a single narrative slug (e.g.,
ai-agents, memes, layer-1,
rwa, defi). All returned counts are scoped to that narrative. Omit for
all narratives.Filter to a single exchange. Legacy aggregate rows are currently populated
for enabled compatibility venues.
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.
Filter to a single exchange. Event filters can include registry venues such
as
bitget, hyperliquid, or aster.Optional listed instrument class:
token, spot_pair, perp_contract,
futures_contract, or options_contract.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 5 MCP resources that provide reference data for valid parameter values and for the fields the tools return.Supported exchanges per product: 35 for funding rates, and 5 default + 5
extra for futures.
The field dictionary: the served fields that have an entry (funding and
open interest today), by the id the API document gives each (
x-field),
with its label, unit or type, meaning, grain, source and what null
means.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
Required. API key, on a paid plan or in its one-time trial; every tool calls
/api/v1/ with it
and draws on the key’s quota. Without it the server starts and lists its
tools, and every tool call answers how to get a key.Site root for API calls. Defaults to
https://www.sharpe.ai;
legacy /api or /api/v1 base values are normalized.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.
Paging and the context window
Atype=current read of get_funding_rates leaves out the rows not written
for 6 hours, as /v1/funding/rates does.
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, get_arbitrage_spot_perp, get_news
and get_funding_settlement ask for a 25-row page when the call names none.
get_api_coverage takes no page and is never cut: it answers whole.
Get an API key
Choose a plan at /pricing and pay at /dashboard/billing, then create your key from the API key dashboard and set it asSHARPE_API_KEY in your MCP client configuration (or send it as the Authorization header to the hosted endpoint). The full key is shown once at creation time. Each account has one key, shared by the REST API and the MCP server.

