Skip to main content
Glama
CryptoAPIs-io

@cryptoapis-io/mcp-transactions-data

Official

@cryptoapis-io/mcp-transactions-data

MCP server for Crypto APIs Transactions Data product. Look up transaction details by hash across EVM, UTXO, Solana, XRP, and Kaspa blockchains.

API Version: Compatible with Crypto APIs version 2024-12-12

Features

  • UTXO: Get transaction details and raw transaction data (Bitcoin, Bitcoin Cash, Litecoin, Dogecoin, Dash, Zcash)

  • EVM: Get transaction details, internal transactions, token transfers, and logs (Ethereum, Ethereum Classic, BSC, Polygon, Avalanche (C-Chain), Arbitrum, Base, Optimism, Tron)

  • Solana: Get transaction details by signature

  • XRP: Get transaction details

  • Kaspa: Get transaction details by transaction ID

Related MCP server: @cryptoapis-io/mcp-prepare-transactions

Prerequisites

Installation

npm install @cryptoapis-io/mcp-transactions-data

Or install all Crypto APIs MCP servers: npm install @cryptoapis-io/mcp

Usage

# Run with API key
npx @cryptoapis-io/mcp-transactions-data --api-key YOUR_API_KEY

# Or use environment variable
export CRYPTOAPIS_API_KEY=YOUR_API_KEY
npx @cryptoapis-io/mcp-transactions-data

# HTTP transport (listens on 127.0.0.1; see "Exposing the server beyond localhost")
npx @cryptoapis-io/mcp-transactions-data --transport http --port 3000 --api-key YOUR_API_KEY

Claude Desktop

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "cryptoapis-transactions-data": {
      "command": "npx",
      "args": ["-y", "@cryptoapis-io/mcp-transactions-data"],
      "env": {
        "CRYPTOAPIS_API_KEY": "your_api_key_here"
      }
    }
  }
}

Cursor

Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "cryptoapis-transactions-data": {
      "command": "npx",
      "args": ["-y", "@cryptoapis-io/mcp-transactions-data"],
      "env": {
        "CRYPTOAPIS_API_KEY": "your_api_key_here"
      }
    }
  }
}

MCP Inspector

npx @modelcontextprotocol/inspector npx @cryptoapis-io/mcp-transactions-data --api-key YOUR_API_KEY

n8n

  1. Start the server in HTTP mode:

    npx @cryptoapis-io/mcp-transactions-data --transport http --port 3000 --api-key YOUR_API_KEY
  2. In your n8n workflow, add an AI Agent node

  3. Under Tools, add an MCP Client Tool and set the URL to http://localhost:3000/mcp

n8n in Docker: localhost inside the container is not your machine. Start the server with --host 0.0.0.0 and MCP_AUTH_TOKEN set (see Exposing the server beyond localhost), use http://host.docker.internal:3000/mcp as the URL, and add an Authorization: Bearer <token> header to the MCP Client Tool credential.

All servers default to port 3000. Use --port to assign different ports when running multiple servers.

Available Tools

transactions_data_utxo

UTXO transaction details (Bitcoin, Bitcoin Cash, Litecoin, Dogecoin, Dash, Zcash).

Action

Description

get-transaction-details

Get transaction details by hash

get-raw-transaction-data

Get raw transaction data by hash

transactions_data_evm

EVM transaction details (Ethereum, Ethereum Classic, BSC, Polygon, Avalanche (C-Chain), Arbitrum, Base, Optimism, Tron).

Action

Description

get-transaction-details

Get transaction details by hash

list-internal-transactions

List internal transactions by hash

list-token-transfers

List token transfers by hash

list-logs

List event logs by hash

transactions_data_solana

Solana transaction details (mainnet, devnet).

Parameter

Description

network

Network (mainnet, devnet)

transactionHash

Transaction signature

transactions_data_xrp

XRP transaction details (mainnet, testnet).

Parameter

Description

network

Network (mainnet, testnet)

transactionHash

Transaction hash

transactions_data_kaspa

Kaspa transaction details (mainnet).

Parameter

Description

network

Network (mainnet)

transactionId

Transaction ID

CLI Arguments

Argument

Description

Default

--api-key

Crypto APIs API key

CRYPTOAPIS_API_KEY env var

--transport

Transport type: stdio or http

stdio

--host

HTTP host (use 0.0.0.0 to accept remote connections — requires an auth token with --api-key)

127.0.0.1

--auth-token

Bearer token callers must send (Authorization: Bearer <token>); prefer the MCP_AUTH_TOKEN env var

MCP_AUTH_TOKEN env var

--allowed-hosts

Comma-separated Host header allowlist for non-loopback binds

—

--port

HTTP port

3000

--path

HTTP path

/mcp

--stateless

Enable stateless HTTP mode

false

HTTP API Key Modes

When using HTTP transport, the server supports two API key modes:

  • With --api-key: The key is used for all requests. x-api-key request headers are ignored.

  • Without --api-key: Each request must include an x-api-key header with a valid Crypto APIs key. This enables hosting a public server where each user provides their own key.

# Per-request key mode (multi-tenant)
npx @cryptoapis-io/mcp-transactions-data --transport http --port 3000
# Clients send x-api-key header with each request

Exposing the server beyond localhost

HTTP mode listens on 127.0.0.1 by default, so only processes on the same machine can reach it. To accept connections from other machines or containers, bind explicitly and protect the port:

# Startup-key mode: callers must present the token (the server refuses to start without one)
export MCP_AUTH_TOKEN=$(openssl rand -hex 32)
npx @cryptoapis-io/mcp-transactions-data --transport http --host 0.0.0.0 --port 3000 --api-key YOUR_API_KEY \
  --allowed-hosts mcp.internal.example
# Clients send: Authorization: Bearer $MCP_AUTH_TOKEN

# Per-request key mode: no startup key, every request must carry the caller's own x-api-key
npx @cryptoapis-io/mcp-transactions-data --transport http --host 0.0.0.0 --port 3000

--allowed-hosts restricts the Host header (DNS rebinding protection) when not bound to loopback. Prefer MCP_AUTH_TOKEN over --auth-token: command-line arguments are visible in the process list.

Stdio transport always requires an API key at startup.

Important: API Key Required

Warning: Making requests without a valid API key — or with an incorrect one — may result in your IP being banned from the Crypto APIs ecosystem. Always ensure a valid API key is configured before starting any server.

Remote MCP Server

Crypto APIs provides an official remote MCP server with all tools available via HTTP Streamable transport at https://ai.cryptoapis.io/mcp. Pass your API key via the x-api-key header — no installation required.

License

MIT

Available Tools

6 tools
system_infoA

CryptoAPIs reference documentation — no API call, no credits consumed.

Actions: • blockchains — Supported blockchains, networks, products per chain, denominations, fiat currencies • errors — Complete error code table (HTTP status, error code, message) • credits — Credit charging structure, cost multipliers per blockchain, monitoring & operations taxes (xPub, synced addresses, blockchain events), pay-as-you-go • callbacks — Webhook mechanics: URL requirements, retry strategy (5 retries, exponential backoff), HMAC security, idempotency • limits — Throughput soft/hard limits per plan, 2.1x penalty multiplier, rate limiting behavior

ParametersJSON Schema
NameRequiredDescriptionDefault
actionYesReference topic to retrieve
contextNoOptional context for the request - echoed back in response

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and explicitly notes 'no API call, no credits consumed,' which is key behavioral information. It also discloses detailed content such as retry strategy, HMAC security, and rate-limit penalty multipliers, going well beyond a generic 'returns info' statement.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the critical 'no API call, no credits consumed' caveat and uses a compact bullet list. Each bullet covers a distinct action without wasted prose, making it highly scannable for an agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a reference-documentation tool with no output schema and no annotations, this description is complete enough: it defines all five actions and gives sufficient detail about their content. It also clarifies side effects (none) and cost implications (none), covering the main contextual risks.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although schema coverage is 100%, the description adds significant meaning by explaining each allowed action enum value in detail (e.g., callbacks covers URL requirements, 5 retries, HMAC). This transforms enum names into actionable context and compensates fully beyond the schema's short parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states this is CryptoAPIs reference documentation with no API call or credits consumed, and enumerates five specific topics (blockchains, errors, credits, callbacks, limits). This clearly identifies it as an informational tool distinct from domain siblings like aml.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The bulleted actions give clear contexts for when to use the tool, such as looking up error codes, credit structures, callback mechanics, or rate limits. It does not explicitly name alternatives or exclusion conditions, so it stops short of a full when/when-not specification.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

transactions_data_evmB

Transactions Data EVM: get transaction details, internal transactions, token transfers, or logs by transaction hash.

Actions: get-transaction-details, list-internal-transactions, list-token-transfers, list-logs.

Credits by action (source: OpenAPI): • get-transaction-details: arbitrum 192, avalanche 216, base 144, binance-smart-chain 300, ethereum 120, ethereum-classic 156, optimism 168, polygon 240, tron 180 • list-internal-transactions: arbitrum 512, avalanche 576, base 384, binance-smart-chain 800, ethereum 320, ethereum-classic 416, optimism 448, polygon 640, tron 480 • list-logs: arbitrum 192, avalanche 216, base 144, binance-smart-chain 300, ethereum 120, ethereum-classic 156, optimism 168, polygon 240, tron 180 • list-token-transfers: arbitrum 352, avalanche 396, base 264, binance-smart-chain 550, ethereum 220, ethereum-classic 286, optimism 308, polygon 440, tron 330

Credits are indicative only and may change at any time. The actual credits spent for each API request are returned in the response headers.

ParametersJSON Schema
NameRequiredDescriptionDefault
actionYesAction to perform
contextNoOptional context for the request - echoed back in response
networkYesNetwork name
blockchainYesBlockchain protocol
transactionHashYesTransaction hash

TDQS

B3.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses credit costs per action and blockchain, which is a trait beyond the schema, but does not state read-only nature, rate limits, pagination, or what each action returns.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose and actions are front-loaded, and the credit table, while long, provides actionable cost data. Some repetition in the credits section is minor.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should explain return values for each action and behavior like authentication or error handling. It covers costs but leaves the agent without enough to interpret results or handle all four actions confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents every parameter. The description adds no parameter semantics beyond repeating the action enum values; blockchain, network, and transactionHash receive no extra meaning.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (get) and the resources (transaction details, internal transactions, token transfers, logs) scoped by transaction hash, and lists the four actions clearly. It does not explicitly differentiate from siblings like transactions_data_utxo, though the 'EVM' in the name implies chain scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to choose one action over another, nor when to use this tool versus the UTXO/Solana/XRP/Kaspa siblings. Only an implicit 'use it to get transaction data' is present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

transactions_data_kaspaB

Transactions Data Kaspa: get transaction details by transaction ID. Network: mainnet.

Credits per call: 918

Credits are indicative only and may change at any time. The actual credits spent for each API request are returned in the response headers.

ParametersJSON Schema
NameRequiredDescriptionDefault
contextNoOptional context for the request - echoed back in response
networkYesNetwork name
transactionIdYesTransaction ID

TDQS

B3.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses credit cost and where actual credits appear, and implies a read-only lookup, but omits auth requirements, rate limits, and response behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose and network are front-loaded in one sentence, followed by concise credit information. The leading tool-name restatement is slightly redundant, but the overall definition is compact.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple lookup with 100% schema coverage, the description gives enough to invoke the tool correctly. However, with no output schema and no annotations, it does not describe the response structure or operational constraints an agent might need.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters. The description mentions transaction ID and mainnet but adds no format or usage detail beyond the structured fields.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: get transaction details by transaction ID. It scopes to Kaspa mainnet, which differentiates it from sibling transaction tools for UTXO, EVM, Solana, and XRP.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not explain when to use this tool instead of the sibling transaction-data tools. It only states the network is mainnet, leaving alternative selection to the agent's inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

transactions_data_solanaB

Transactions Data Solana: get transaction details by transaction hash (signature). Networks: mainnet, devnet.

Credits per call: 90

Credits are indicative only and may change at any time. The actual credits spent for each API request are returned in the response headers.

ParametersJSON Schema
NameRequiredDescriptionDefault
contextNoOptional context for the request - echoed back in response
networkYesNetwork name
transactionHashYesTransaction hash (signature)

TDQS

B3.2/5.0
Behavior3/5

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 does add genuinely useful non-schema context — a 90-credit cost, the caveat that credits are indicative, and that actual spend is in response headers — but it omits error behavior (e.g. unknown hash) and any rate-limit or auth detail.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with purpose before network list and the credits boilerplate. The credits disclaimer is somewhat boilerplate-heavy but earns its place by setting cost expectations for a paid call.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should say more about the returned transaction shape and error cases. It covers purpose, supported networks, and cost adequately, but leaves the response contract to inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description only restates the network enum and the hash meaning, adding no syntax or format detail beyond it; baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'get transaction details by transaction hash (signature)', and the Solana suffix distinguishes it from the sibling chain variants (utxo, evm, xrp, kaspa). Clear, though it does not explicitly contrast itself with those siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use or when-not-to-use guidance. The only routing cue is the tool name's chain suffix; nothing tells the agent to prefer this over transactions_data_evm for a Solana/EVM ambiguity, nor any prerequisite or failure conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

transactions_data_utxoB

Transactions Data UTXO: get transaction details or raw transaction data by hash.

Actions: get-transaction-details, get-raw-transaction-data. Blockchains: bitcoin, bitcoin-cash, litecoin, dogecoin, dash, zcash. Networks: mainnet, testnet.

Credits by action (source: OpenAPI): • get-raw-transaction-data: bitcoin 110, bitcoin-cash 132, dash 121, dogecoin 121, litecoin 121, zcash 143 • get-transaction-details: bitcoin 110, bitcoin-cash 132, dash 121, dogecoin 121, litecoin 121, zcash 143

Credits are indicative only and may change at any time. The actual credits spent for each API request are returned in the response headers.

ParametersJSON Schema
NameRequiredDescriptionDefault
actionYesAction to perform
contextNoOptional context for the request - echoed back in response
networkYesNetwork name
blockchainYesBlockchain protocol
transactionHashYesTransaction hash

TDQS

B3.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry full behavioral disclosure. It provides useful cost information (credits per action/blockchain, indicators, headers) but omits whether the operation is read-only, idempotent, or requires special authorization. Some behavioral context is present but key traits are missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and key lists are front-loaded, but the credit list is duplicated for both actions despite identical values and the disclaimer could be trimmed. Moderately structured with noticeable redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description covers actions, supported chains, networks, and costs. It still lacks guidance on action selection and expected response differences between the two actions, which are important for a two-action tool. Adequate but not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the schema already documents all parameters. The description repeats the action, blockchain, and network enums and adds credit costs per combination, which gives extra meaning for action selection. However, it does not clarify transactionHash format or context usage beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb 'get' and resources 'transaction details or raw transaction data by hash', and lists supported blockchains and networks. This indirectly distinguishes it from siblings like transactions_data_evm, but does not explicitly name alternatives or scope exclusions. Clear but lacks direct sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description lists the two actions but provides no guidance on when to use each, nor when to prefer this tool over sibling transaction tools. No prerequisites or when-not conditions are given. Essentially no usage guidelines beyond the action enumeration.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

transactions_data_xrpB

Transactions Data XRP: get transaction details by transaction hash. Networks: mainnet, testnet.

Credits per call: 110

Credits are indicative only and may change at any time. The actual credits spent for each API request are returned in the response headers.

ParametersJSON Schema
NameRequiredDescriptionDefault
contextNoOptional context for the request - echoed back in response
networkYesNetwork name
transactionHashYesTransaction hash

TDQS

B3.2/5.0
Behavior3/5

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 discloses cost (110 credits, indicative, returned in response headers) and the supported networks, which is useful context, but says nothing about auth requirements, error cases, or whether results are cached/finalized.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the core action and resource, then networks and cost. The credit boilerplate is slightly verbose but earns its place by disclosing billing behavior.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A read-only lookup with 100% parameter documentation and no output schema; the description covers the two things the schema cannot (supported networks and cost). Nothing essential for a correct call is missing, though chain-routing guidance would fully close the gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the enum for network is declared, so the schema fully documents all three parameters. The description only restates 'transaction hash' and the network list, adding no syntax or format details beyond the structured fields. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb+resource: 'get transaction details by transaction hash' on the XRP network. It does not explicitly differentiate itself from the chain-specific siblings (evm, solana, utxo, kaspa), though the name and 'XRP' label imply the chain routing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use, prerequisites, or alternative routing guidance. With four sibling transaction tools for other chains, the agent gets no explicit statement that this is the XRP-chain variant and should be selected only for XRP hashes.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 6 tool updatesv0.4.0
    • First observedsystem_info
    • First observedtransactions_data_evm
    • First observedtransactions_data_kaspa
    • First observedtransactions_data_solana
    • First observedtransactions_data_utxo
    • First observedtransactions_data_xrp

TDQS

A3.5/5.0

Scored across 6 tools

Disambiguation4/5

Tools are partitioned cleanly by blockchain family (UTXO, EVM, Solana, XRP, Kaspa), and the EVM tool's multi-action nature is distinct from the simpler single-action chain tools. Minor residual overlap since Solana/XRP/Kaspa tools all do essentially 'get transaction details by hash', but the chain scoping keeps selections unambiguous.

Naming Consistency4/5

All five data tools share a strict `transactions_data_<chain>` pattern, which is highly predictable. The lone `system_info` tool deviates from the family prefix but is a clearly distinct meta/reference tool, so the break is minor.

Tool Count4/5

Six tools is well-scoped for a transaction-data retrieval product, with each chain family earning its own tool. No bloat or obvious redundancy, though splitting the low-action chains (Solana/XRP/Kaspa) into separate tools is slightly granular.

Completeness4/5

The surface covers the read/lifecycle needs of fetching transaction data across major chain families, with EVM richly covered (details, internal txs, token transfers, logs). Coverage is read-only by nature, but there is no address-based transaction listing, which is a plausible gap for transaction workloads.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers