token-verdict-mcp
One-line summary: This server exposes a single MCP tool for paid token risk screening via Token Verdict.
Call
token_verdictwith a token contractaddressand optionalchain(basedefault,ethereum, orsolana).Get back a risk verdict (
SOLID/CAUTION/DANGER), a 0–100 risk score, six weighted market-structure signals, an analyst take, and raw market data.Signals cover liquidity depth, volume churn, sell pressure, price action, trader breadth, and pair age.
Paid calls cost $0.02 USDC on Base via x402; without a configured signer, the tool returns a structured
payment_requiredchallenge instead of paying.The service is market-structure analysis only; it does not check honeypots or holder concentration.
Supports token risk analysis for token contracts on Ethereum by selecting the Ethereum chain, returning a verdict, risk score, six market-structure signals, and underlying market data.
Supports token risk analysis for token contracts on Solana by selecting the Solana chain, returning a verdict, risk score, six market-structure signals, and underlying market 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., "@token-verdict-mcp what's the risk verdict for this Base token: 0x4200000000000000000000000000000000000006"
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.
token-verdict-mcp
Standalone home: This server was split out of
QuincyGB/token-verdict-toolsso each MCP server has its own GitHub repository for directory ingestion and maintenance. The PyPI package name (token-verdict-mcp), version, and install command are unchanged.
An MCP server (stdio transport) that exposes Token Verdict as a native tool for any MCP host — Claude Desktop, Cursor, or your own agent runtime.
Token Verdict is a pay-per-call token risk screen for AI agents: send a token contract address, get back a verdict (SOLID / CAUTION / DANGER), a 0–100 risk score, six weighted market-structure signals explained in plain English, and a written analyst take. It costs $0.02 USDC per call on Base, paid via the x402 protocol — no accounts, no API keys; the payment is the authentication.
The tool
token_verdict — one tool, the service's real contract:
Input | Type | Notes |
| string (required) | Token contract address ( |
| string, default |
|
Output is the service's verdict JSON: token, verdict, score,
signals (exactly six), take, and market (the raw data the verdict
derives from, so callers can re-check the math). Market-structure
analysis only — honeypot simulation and holder concentration are not
checked, and the product says so in every take.
Related MCP server: verdix
Install
pip install token-verdict-mcp
# Or from a checkout of this repository:
pip install .Requires Python ≥ 3.10. The server pins the MCP v1 SDK API
(mcp>=1.2,<2).
Configuration
All configuration is the operator's own environment — whoever runs this server supplies their own wallet. No key material ships in this package, and the package author never sees your key.
Env var | Required | Purpose |
| for paid calls | EVM private key ( |
| alternative | Path to a file containing that key. |
| no | Service base URL override (default: production). |
| no | Spend guard per call in USDC micro-units (default |
Without a signer configured the tool never pays. On a 402 it
returns the parsed challenge as a structured error — error: "payment_required" with the full accepts array (scheme, network,
asset, amount, payTo) — so the calling agent can see the price and
decide what to do, or settle the challenge with its own x402 client.
MCP host configuration
Claude Desktop (claude_desktop_config.json) — same shape for other
stdio MCP hosts:
{
"mcpServers": {
"token-verdict": {
"command": "token-verdict-mcp",
"env": {
"AGENT_PRIVATE_KEY": "0xYOUR_OWN_WALLET_KEY"
}
}
}
}From a checkout instead of an install:
{
"mcpServers": {
"token-verdict": {
"command": "python",
"args": ["-m", "token_verdict_mcp"],
"env": {
"PYTHONPATH": "/path/to/token-verdict-mcp/src",
"AGENT_KEY_FILE": "/path/to/your/agent.key"
}
}
}
}Prefer AGENT_KEY_FILE over inlining a key in a config file when your
host setup allows it.
How payment works
The client mirrors the standard x402 v2 flow (the same flow used for the service's own live cataloging payment):
POST /v1/verdictunpaid → HTTP 402, challenge base64-encoded in thepayment-requiredheader.Pick the
exact/eip155:8453entry fromaccepts.Build an EIP-3009
TransferWithAuthorization(validAfter: 0,validBefore: now + maxTimeoutSeconds, random 32-byte nonce) and sign it as EIP-712 typed data against the USDC domain the challenge advertises (extra.name/extra.version).Retry the identical POST with the payload in the
PAYMENT-SIGNATUREheader. The service verifies and settles through its facilitator (PayAI) server-side; the settlement receipt comes back in thepayment-responseheader.
Tests
pip install -e ".[dev]"
pytest14 tests, all payments mocked (httpx MockTransport, throwaway signer
generated at test time). The 402 fixture is the real challenge captured
from production; the paid-flow test verifies the EIP-712 signature
actually recovers to the signer address.
Security notes
Your private key is read from your environment at runtime and used only to sign payment authorizations locally. It is never transmitted — the x402 payload contains a signature, not a key.
The spend guard caps any single call at the configured amount (default: exactly the $0.02 price).
Run this with a dedicated agent wallet holding only working funds, the same way you would fund any agent.
Available Tools
1 tooltoken_verdictA
Get a risk verdict for a token before buying, swapping, or routing funds into it.
Calls Token Verdict (POST /v1/verdict, $0.02 USDC on Base via x402).
Returns verdict (SOLID / CAUTION / DANGER), a 0-100 risk score, six
weighted market-structure signals (liquidity depth, volume churn,
sell pressure, price action, trader breadth, pair age), a written
analyst take, and the raw market data the verdict derives from.
Args:
address: Token contract address (0x...).
chain: Chain label — "base" (default), "ethereum", or "solana".
Inputs: address (required), chain. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 1 tool
There is only one tool, so there is no possibility of selecting the wrong one. Its purpose—fetching a pre-trade risk verdict for a token address—is stated unambiguously.
The name token_verdict uses clean snake_case and mirrors the backing service name, but it is a noun phrase rather than the verb_noun pattern typical of action-oriented tool sets. With only one tool there is no inconsistency to speak of, just a minor stylistic deviation.
The server wraps a single paid x402 endpoint ($0.02 USDC per call), so one tool is defensible and each tool does earn its place. However, a one-tool surface is thin and sits at the borderline of the 1-2 tool range.
For the narrow stated purpose—pre-trade risk assessment—the tool returns everything needed: verdict, 0-100 score, six weighted signals, analyst commentary, and raw market data. Minor gaps exist (no batch/multi-token lookup, no way to enumerate supported chains beyond the description), but agents can work around these with the documented chain argument.
Maintenance
Related MCP Connectors
Smart-contract risk reports for AI agents on 20 EVM chains, paid per call via x402 ($0.02 USDC).
Pre-trade token risk scoring API for Base tokens, paid via x402.
Solana address risk grades and token scans for AI agents. Pay-per-call via x402 (USDC on Base).
Parallel Solana token risk and transaction safety for AI agents. Paid MCP tools inspect tokens and unsigned transactions; the HTTP risk panel queries compatible advisors in parallel and returns an indicative consensus. x402-compatible clients pay USDC automatically, with no signup or API key.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables MCP-capable AI agents to make pay-per-call Solana data requests (snapshots, risk checks, token reports, health, balances, transactions, trending pairs) with automatic USDC settlement over x402.5MIT
- AlicenseAqualityBmaintenanceEnables AI agents to check an EVM address on Base for risk (safe, caution, danger) before sending funds, with reasons, paid per call via x402 from the user's own wallet.7135 npm1MIT
- AlicenseAqualityCmaintenanceEnables AI assistants to call pay-per-call x402 endpoints on Base mainnet using the caller's own USDC wallet, covering single and batch token risk checks, the latest BTC radar signal, project info, and a free health probe. Payments are EIP-3009 signed with a configurable per-call spending cap, and any quote with an unexpected payee, network, or asset is refused before payment.5MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to access pay-per-call onchain and URL safety APIs over MCP, covering transaction explanations, token approval checks, address inspection, contract risk heuristics, URL safety, gas snapshots, ENS resolution, calldata decoding, and wallet portfolio data. Payments are handled per call in USDC on Base via x402, with no signup or API key required.1MIT