The CryptoQuant MCP Server provides on-chain cryptocurrency analytics and market insights to AI assistants through natural language queries and structured API tools.
Natural Language Queries: Ask questions in any language (e.g., "Is BTC overvalued?", "비트코인 가격 전망?") and Claude automatically routes them to the appropriate on-chain metrics for AI-powered interpretation.
Session Management: Authenticate via environment variable (CRYPTOQUANT_API_KEY) or direct parameter using initialize() to unlock your plan details. Use reset_session to clear credentials or switch accounts.
Data Discovery:
discover_endpoints — Browse 245+ API endpoints filtered by asset and category (market-data, exchange-flows, network-data, miner-flows, etc.)
get_endpoint_info — Retrieve detailed parameter options for any endpoint
list_assets — View all supported assets (BTC, ETH, ALT, Stablecoin, ERC20, TRX, XRP) and their data categories
Data Access:
query_data — Fetch real-time or historical on-chain data with flexible parameters (time range, exchange, market type, granularity, up to 1000 data points)
describe_metric — Get in-depth explanations, thresholds, and interpretation guidance for metrics like MVRV, SOPR, funding rates, exchange flows, and whale activity
Integrations: Works with Claude Desktop, Claude Code, Cursor, and other MCP-compatible applications.
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 "Install 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 MCP Server brings on-chain analytics directly into your AI assistant:
Natural language queries: Ask in any language - "비트코인 가격 전망?" or "Is BTC overvalued?"
Real-time metrics: MVRV, SOPR, Exchange Flows, Funding Rates
Market insights: AI-powered interpretation of on-chain data
Whale tracking: Monitor large holder movements
Related MCP server: Coin Railz MCP Server
Step 1: Add to your MCP config file:
App | Config File |
Claude Desktop (Mac) |
|
Claude Desktop (Windows) |
|
Claude Code |
|
Cursor | Project |
{
"mcpServers": {
"cryptoquant": {
"command": "npx",
"args": ["-y", "cryptoquant-mcp"]
}
}
}Step 2: Restart your app
Step 3: Call initialize() to verify connection. Done!
For contributors:
git clone https://github.com/CryptoQuantOfficial/cryptoquant-mcp.git
cd cryptoquant-mcp
npm install && npm run buildThe MCP server provides these tools for API access:
Tool | Description |
| Start session with API key, returns plan info |
| Browse 245+ available endpoints |
| Get endpoint parameter details |
| Query raw API data |
| Get metric descriptions and thresholds |
| List supported assets |
| Clear session (logout) |
BTC, ETH, ALT, Stablecoin, ERC20, TRX, XRP
Ask questions in any language - Claude will route to the right metrics:
Query | Intent | Metric |
"비트코인 가격 전망이 어때?" | VALUATION | MVRV |
"Is BTC overvalued?" | VALUATION | MVRV |
"고래들 움직임 보여줘" | WHALE_ACTIVITY | whale-ratio |
"What's the funding rate?" | LEVERAGE | funding-rates |
"익절/손절 상황?" | PROFIT_BEHAVIOR | SOPR |
Add your API key to the MCP config:
{
"mcpServers": {
"cryptoquant": {
"command": "npx",
"args": ["-y", "cryptoquant-mcp"],
"env": {
"CRYPTOQUANT_API_KEY": "your-api-key"
}
}
}
}Call initialize() with your API key:
initialize(api_key="your-api-key")The key will be saved to ~/.cryptoquant/credentials for future sessions.
Get your API key: https://cryptoquant.com/settings/api
# Switch accounts
reset_session(clear_stored=true)
initialize(api_key="new-api-key")Component | Requirement |
Node.js | v18+ |
API Access |
MIT License - see LICENSE
After cloning the repository, install dependencies to set up git hooks:
npm installThis automatically configures husky for pre-commit hooks.
When committing changes to src/, ESLint runs automatically:
Lint check runs only when files in src/ are staged
Commit is blocked if lint errors are found
Fix errors before committing: npm run lint
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.
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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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.
Open API Marketplace for AI Agents. Crypto data tools with USDC payments on Base.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/CryptoQuantOfficial/cryptoquant-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server