Connect an AI agent to CryptoQuant's on-chain, market, derivatives, Research, and QuickTake data over MCP.
Query raw data (query_data) for on-chain, market, and derivatives metrics, filtered by window, date range, exchange, entity type, miner, token, market, symbol, or limit (max 1000 points).
Discover endpoints (discover_endpoints) by asset (BTC, ETH, XRP, TRX, stablecoins, ERC-20, altcoins) and category (market-data, exchange-flows, network-data, miner-flows, ...), with optional search and restricted-endpoint inclusion.
Inspect endpoints (get_endpoint_info) for available parameter values before querying.
List assets (list_assets) with their available data categories.
Explain metrics (describe_metric) — definitions, thresholds, and interpretation guidance (e.g. mvrv, sopr, netflow).
Read and search research — latest/most recent CryptoQuant Research and QuickTake articles, plus topic search (recent_research, recent_quicktake, query_research, query_quicktake).
Connect remotely with OAuth via https://mcp.cryptoquant.com/mcp (no API key needed), or locally through the npx cryptoquant-mcp stdio proxy with CRYPTOQUANT_API_KEY.
Plan-aware access — the server reports your plan's rate limits and data history on connection.
Note: the schema shown still lists initialize/reset_session (0.x tools); the README says 1.0 removed them in favor of configuring CRYPTOQUANT_API_KEY directly.
Provides tools for accessing on-chain analytics for XRP, enabling AI agents to monitor real-time metrics, track whale activity, and analyze market valuation data.
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., "@CryptoQuant MCP Server Is Bitcoin overvalued right now based on the MVRV ratio?"
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.
CryptoQuant on-chain, market, and derivatives data, plus CryptoQuant Research and QuickTake insights, for AI agents through the Model Context Protocol.
This repository contains:
Remote server setup for https://mcp.cryptoquant.com/mcp (recommended; you sign in with OAuth)
An Agent Plugins / Cursor plugin (plugin.json, mcp.json, skills/) that connects to the remote server and teaches the agent which metric answers which question
A local stdio proxy (npx cryptoquant-mcp) for clients that cannot connect to remote MCP servers. It forwards every message to the remote server unchanged.
Server URL: https://mcp.cryptoquant.com/mcp (Streamable HTTP, OAuth)
No API key is needed in your config. The first time you connect, your client opens a CryptoQuant sign-in page. More setup details: CryptoQuant user guide.
Open Settings → Connectors → Add custom connector and paste the server URL.
Add a custom connector with the server URL (developer mode). Availability depends on your ChatGPT plan.
Install the CryptoQuant plugin from the Cursor marketplace (once listed). It adds the remote server and the cryptoquant-onchain skill.
Or add the server yourself in .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):
{
"mcpServers": {
"cryptoquant": {
"url": "https://mcp.cryptoquant.com/mcp"
}
}
}.vscode/mcp.json:
{
"servers": {
"cryptoquant": {
"type": "http",
"url": "https://mcp.cryptoquant.com/mcp"
}
}
}claude mcp add --transport http cryptoquant https://mcp.cryptoquant.com/mcpThen run /mcp in Claude Code to sign in.
Related MCP server: Simsar MCP
For clients that only support local (stdio) servers. Requires Node.js 18+ and a CryptoQuant API key.
{
"mcpServers": {
"cryptoquant": {
"command": "npx",
"args": ["-y", "cryptoquant-mcp"],
"env": {
"CRYPTOQUANT_API_KEY": "your-api-key"
}
}
}
}App | Config file |
Claude Desktop (macOS) |
|
Claude Desktop (Windows) |
|
Cursor |
|
Claude Code | project |
Variable | Required | Description |
| Yes | Your API key, sent to the remote server as a bearer token. If it is not set, the key saved by 0.x in |
| No | Overrides the server URL (default |
Without a key, the proxy prints setup instructions to stderr and exits.
The tools come from the remote server. This list is for reference and may change.
Tool | Description |
| Find data endpoints by asset and category |
| Parameters of an endpoint (window, exchange, token, ...) |
| Query on-chain, market, and derivatives data |
| Definition, thresholds, and interpretation of a metric |
| Supported assets |
| Latest CryptoQuant Research articles |
| Latest QuickTake articles from CryptoQuant Verified Authors |
| Search Research articles by topic |
| Search QuickTake articles by topic |
Assets: BTC, ETH, XRP, TRX, stablecoins, ERC-20 tokens, and other altcoins. list_assets returns the current list.
Dates: yyyyMMdd for window=day (e.g. 20260115), yyyyMMddTHHmmss for other windows (e.g. 20260115T000000).
Rate limits and history: depend on your CryptoQuant plan. The server tells the agent your plan's limits when it connects. See plans.
1.0 turns the npm package into a proxy to the remote server, so the local and remote servers now offer the same tools.
The initialize and reset_session tools are removed. Set CRYPTOQUANT_API_KEY in your MCP config instead. A key you saved in 0.x with initialize(api_key=...) keeps working; it is read from ~/.cryptoquant/credentials.
QuickTake and Research tools are now available locally.
The package no longer exports a JavaScript library API.
CRYPTOQUANT_API_URL (the 0.x API base URL override) is no longer used; use CRYPTOQUANT_MCP_URL to point at another MCP server.
npx -y cryptoquant-mcp always fetches the latest version, so existing configs switch to 1.0 on the next start. Prompts or workflows that call initialize need to be updated.
See CHANGELOG.md.
git clone https://github.com/CryptoQuantOfficial/cryptoquant-mcp.git
cd cryptoquant-mcp
npm install
npm test
npm run buildSee CONTRIBUTING.md.
MIT. See LICENSE.
Get detailed description for a specific metric. Use only when user asks 'what is X?' or metric is unfamiliar. Returns thresholds, interpretation guidance, and category info.
| Name | Required | Description | Default |
|---|---|---|---|
| metric_id | Yes | The metric ID to describe (e.g., 'mvrv', 'sopr', 'netflow') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It mentions return types (thresholds, interpretation, category info) but does not explicitly state it's a read-only operation or any side effects. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first defines purpose, second adds usage guidance and return content. No unnecessary words, front-loaded effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description adequately covers purpose, usage, and return content. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a clear description of metric_id. The description adds usage context but does not enhance meaning of the parameter itself. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it retrieves a detailed description for a specific metric, listing examples like thresholds and interpretation guidance. This distinguishes it from sibling tools like query_data or list_assets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says to use only when user asks 'what is X?' or metric is unfamiliar. This provides clear usage context, though it doesn't mention alternatives or when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Discover available API endpoints for a specific asset and category. Call initialize() first to get valid asset/category combinations. Returns endpoint paths and parameter options (e.g., window: ['day', 'hour']). Use returned paths with query_data().
| Name | Required | Description | Default |
|---|---|---|---|
| asset | No | Asset to discover endpoints for. Omit for all assets. | |
| category | No | Category filter (e.g., market-data, exchange-flows, network-data, miner-flows, etc.) | |
| query | No | Search term to filter endpoints by path or metric name | |
| include_restricted | No | Include endpoints not available on your current plan |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes return format (endpoint paths and parameter options with example), but no annotations are provided; description carries burden and is adequate but lacks detail on side effects or auth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each adding distinct value: purpose, prerequisite, post-usage and example. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and 4 optional params, description covers purpose, prerequisite, and example output; lacks full output specification but is fairly complete for a discovery tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage for all 4 parameters; description adds only contextual usage (initialize, query_data) but no extra parameter-specific semantics beyond what schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it 'Discover available API endpoints' for a specific asset and category, differentiating from siblings like initialize and query_data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to call initialize() first and use returned paths with query_data(), providing clear workflow context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get detailed information about a specific API endpoint including available parameter values.
| Name | Required | Description | Default |
|---|---|---|---|
| endpoint | Yes | API endpoint path to get information about |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility for disclosing behaviors. It only states that the tool returns information, implying a read operation, but provides no details on side effects, authorization needs, rate limits, or output structure. Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the core purpose. It is concise and efficient, though slightly vague due to the phrase 'detailed information'. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter and no output schema, the description is brief but covers the essential action. It mentions 'including available parameter values', which is helpful. However, it does not describe the response format or clarify what constitutes 'detailed information'. Adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single required parameter 'endpoint'. The description does not add additional meaning beyond the schema's definition of 'API endpoint path'. Baseline of 3 is appropriate since the schema already handles the parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a specific API endpoint', including 'available parameter values', which adds specificity. It distinguishes from sibling tools like 'discover_endpoints' (which likely lists endpoints) and 'describe_metric' (for metrics). However, 'detailed information' remains somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions. The description simply states what it does without helping an agent decide when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Initialize CryptoQuant session. MUST be called first before any other CryptoQuant tools. Returns available assets (btc, eth, etc.), metric categories per asset (e.g., market-indicator, network-indicator), and your plan. Use the returned asset_categories to know which discover_endpoints() calls are valid.
| Name | Required | Description | Default |
|---|---|---|---|
| api_key | No | API key (optional if CRYPTOQUANT_API_KEY env var is set) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It reveals the tool establishes session state and returns critical data for subsequent calls. Could mention behavior on re-call or session lifetime.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loading the critical requirement, with no wasted words. Efficient and impactful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Explains return values and how to use them, but lacks detail on return structure or format. Given no output schema, slight gap remains. Still fairly complete for an init tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds no parameter details; the api_key parameter's description is already in the schema. No additional semantic value from description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool initializes a CryptoQuant session and must be called first. Describes what it returns (assets, metric categories, plan) and how it relates to sibling tools like discover_endpoints().
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states prerequisite ('MUST be called first') and provides a specific use case for the returned data. Lacks explicit exclusions for when not to use, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all supported assets (cryptocurrencies) with their available data categories.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool lists supported assets but does not disclose behavioral traits such as whether it requires authentication, rate limits, or how 'supported' is determined. Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence of 10 words that is front-loaded with the action and resource. Every word serves a purpose; no unnecessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and no annotations, the description is minimally adequate. It conveys the core purpose and what is returned (list of assets with data categories), but lacks details on pagination, ordering, or scope (e.g., does it include all historical assets?).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so schema coverage is 100%. The description adds no parameter semantics (unnecessary), but the mention of 'available data categories' hints at output content. For a no-parameter tool, this is sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'list' and resource 'supported assets (cryptocurrencies)' and specifies that it includes 'available data categories'. This distinguishes it from sibling tools like 'describe_metric' which focus on metrics rather than assets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. While the simplicity of the tool (0 parameters) implies direct use, the description lacks context for when it is appropriate (e.g., 'Use to get all supported assets before filtering').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query raw data from CryptoQuant API. Workflow: initialize() → discover_endpoints(asset, category) → query_data(endpoint, params). Use endpoint paths and parameter values from discover_endpoints response.
| Name | Required | Description | Default |
|---|---|---|---|
| endpoint | Yes | API endpoint path (e.g., /v1/btc/market-data/mvrv) | |
| params | No | Query parameters |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as rate limits, authentication requirements, or read-only safety. The agent needs more insight into side effects or constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with two sentences, front-loading the purpose and then the workflow. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides the necessary workflow context and schema covers parameters, but it lacks any mention of return format or output behavior, which would help completeness given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Though schema coverage is 100%, the description adds value by instructing the agent to use values from discover_endpoints response, which helps in correctly populating endpoint and params parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries raw data from CryptoQuant API and provides a specific workflow (initialize → discover_endpoints → query_data), distinguishing it from siblings like discover_endpoints or describe_metric.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit workflow instructions and tells the agent to use endpoint paths and parameter values from discover_endpoints response, providing clear context for when to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Clear session and optionally stored credentials. Use cases: (1) Switch accounts - clear_stored=true then initialize(), (2) API key expired - clear_stored=true then initialize(), (3) Refresh session - clear_stored=false. After clearing, call initialize() with your API key.
| Name | Required | Description | Default |
|---|---|---|---|
| clear_stored | No | If true, also clears stored credentials from ~/.cryptoquant/credentials | |
| clear_cache | No | If true, also clears discovery cache (forces fresh API fetch on next initialize) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full disclosure burden. It reveals that the tool clears the session, and optionally stored credentials and cache. It explains the effect of each parameter (e.g., clear_cache forces fresh API fetch). However, it does not explicitly state whether clearing is irreversible or if it affects ongoing operations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: two sentences plus a structured bullet list for use cases. It is front-loaded with the core purpose and wastes no words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description provides complete context: purpose, when to use, parameter semantics, and post-conditions (call initialize). It covers all necessary information for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds significant value beyond the schema by explaining when to use clear_stored=true vs false and clarifying that clear_cache forces a fresh API fetch on the next initialize.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Clear session and optionally stored credentials.' It uses a specific verb and resource, and the sibling tools (e.g., initialize, list_assets) are distinct from this session reset operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides three use cases (switch accounts, API key expired, refresh session) and advises whether to set clear_stored to true or false. It also tells the user to call initialize() after clearing, offering clear next steps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0describe_metricdiscover_endpointsget_endpoint_infoinitializelist_assetsquery_datareset_sessionScored across 7 tools
Each tool has a clearly distinct purpose: session management (initialize, reset_session), asset listing (list_assets), endpoint discovery (discover_endpoints, get_endpoint_info), metric description (describe_metric), and data retrieval (query_data). No two tools overlap in functionality, and the workflow dependencies are well-documented.
All tool names use lowercase snake_case with a consistent verb_noun pattern (e.g., describe_metric, discover_endpoints, list_assets). The sole exception is 'initialize', which is a common concise verb, but it fits the overall pattern and does not break consistency.
With 7 tools, the server is well-scoped for its purpose—covering session management, asset discovery, endpoint exploration, metric description, and data querying. The number is neither too few nor excessive for a specialized data API.
The tool set provides a complete lifecycle for interacting with CryptoQuant's read-only API: initialize session, list assets and categories, discover endpoints, get endpoint details, understand metrics, query data, and reset session. There are no obvious gaps for the stated domain.
Blockchain analytics API for AI agents. Smart Money signals, wallet profiling, token analytics.
Blockchain analytics API for AI agents. Smart Money signals, wallet profiling, token analytics.
52 paid x402 API endpoints for AI agents — crypto, data, DeFi, market intelligence.
Market and on-chain crypto data for AI agents. Pay per call in USDC on Base (x402).
