Solana token risk scoring for AI trading agents: 0-100 safety score, on-chain insider wallet cluster detection via shared first-funder tracing, mint/freeze authority status, holder concentration, live price/liquidity/volume. Batch endpoint for up to 25 mints per call. Free tier (15 req/day, no card).
Scored across 3 tools
The three tools have clear boundaries: single-token risk check, batch risk check, and historical data retrieval. Even though the batch tool is conceptually similar to the single check, its bulk behavior is explicitly described, leaving no ambiguity.
All tool names follow a consistent verb_noun pattern, using snake_case throughout. 'check_token_risk', 'check_token_risk_batch', and 'get_token_risk_history' are predictable and clearly denote their action and object.
With only three tools, the server is tightly scoped to token risk data: live checks, batch checks, and historical queries. Each tool serves a distinct and necessary function with no redundancy or bloat.
For a read-only risk-data API, the toolset covers the essential workflows: evaluating a single token, evaluating multiple tokens efficiently, and reviewing historical risk trends. No obvious dead ends or missing core operations are apparent.
Returns a 0-100 safety score, on-chain insider wallet clusters (wallets sharing a first funder), mint/freeze authority status, holder concentration, and live price/liquidity/volume for a single Solana token mint. Use before recommending or executing a trade on any Solana token. 5 free MCP calls/day, no signup. Then email key or x402.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | Yes | The Solana token mint address to check |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It does this well by specifying the 0-100 score range, the data dimensions returned, and the quota/auth model ('5 free MCP calls/day, no signup. Then email key or x402'). It leaves failure modes or interpretation thresholds unstated, but the core behavior is transparent.
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 carry a substantial amount of useful information: output summary, call trigger, quota, and auth next step. The phrase 'Then email key or x402' is slightly cryptic but not bloated. Structure is efficient and front-loaded.
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 no annotations, the description supplies the key return categories and the invocation context, which is strong coverage for a single-parameter read-style tool. It could go further by explaining how to interpret the 0-100 score or what happens on invalid mints, but it is not incomplete enough to warrant a lower score.
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 for the only parameter, mint, is 100%, so the schema already defines it as 'The Solana token mint address to check.' The description reinforces 'single Solana token mint' but adds no new format, validation, or usage nuance. Baseline 3 applies.
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 uses a specific verb ('Returns') tied to a concrete resource ('a single Solana token mint') and enumerates the outputs: safety score, insider clusters, authority status, holder concentration, and price/liquidity/volume. It also implicitly differentiates from siblings (batch, history) via the 'single token' scoping.
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 a clear trigger: 'Use before recommending or executing a trade on any Solana token.' It does not explicitly name when to choose batch or history alternatives, but the 'single token' phrasing signals the boundary. There are no misleading exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Same as check_token_risk but for up to 25 mints in one call — N mints charged as N calls, same per-call economics as check_token_risk, no bulk discount. All-or-nothing: if the batch can't be fully covered by remaining quota/credit, the whole batch is rejected rather than partially processed.
| Name | Required | Description | Default |
|---|---|---|---|
| mints | Yes | 1-25 Solana token mint addresses |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and does a good job: it discloses batching limits, per-call billing equivalence, no discount, and all-or-nothing rejection. It still relies on referencing check_token_risk for the actual risk-check behavior and does not describe the return format, but the critical behavioral traits are disclosed.
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 contain all necessary information, with the core batching purpose front-loaded. The billing and quota behavior are compactly stated with no filler.
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 one-parameter tool with no output schema, the description covers invocation scope, limits, billing, and failure behavior. It is slightly incomplete only in that it defers the actual risk-check semantics to check_token_risk rather than describing them, but this is acceptable for a thin batch wrapper.
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 schema already provides 100% coverage of the sole parameter with a clear description ('1-25 Solana token mint addresses'). The description adds billing and batching semantics but no new syntactic or format details beyond what the schema provides, so the baseline 3 applies.
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 states the tool is the same as check_token_risk but for up to 25 mints in one call, which clearly identifies the verb (check risk), the resource (Solana tokens), and the batch scope. It differentiates from the sibling check_token_risk by batching and from get_token_risk_history by being a risk check rather than history.
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?
It explicitly says the tool should be used instead of check_token_risk when you have up to 25 mints in one call, and it explains the economics (N mints charged as N calls, no bulk discount) and the all-or-nothing quota behavior. These are concrete conditions for choosing this tool over the single-mint sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns hourly historical data points (safety_score, insider_cluster_count, holder_count, price, liquidity, volume) for a mint over the last N days (max 90). Free and unmetered — no quota, works with or without an API key — pure read from stored history, no live upstream call.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | How many days of history to return (default 30, max 90) | |
| mint | Yes | The Solana token mint address |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full behavioral burden and does so excellently. It discloses that the tool is read-only ('pure read from stored history'), has no quota ('Free and unmetered'), needs no API key ('works with or without an API key'), and makes no live upstream call. This is rich, useful behavioral context.
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 three tight sentences with no filler. It front-loads the core function and returned fields, then adds the behavioral caveats. Every clause earns its place and the structure is easy to scan.
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 two-parameter read-only tool with no annotations and no output schema, the description is remarkably complete. It covers purpose, output shape (listed fields), time window, quota, auth, and upstream behavior. An agent has everything needed to call it 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 description coverage is 100%, so both mint and days are already documented. The description reinforces the max-90-day limit and adds hourly granularity, but it does not add meaningful new parameter-level meaning beyond the schema. 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?
The description uses a specific verb ('Returns') with a clear resource ('historical risk trend for a Solana token') and enumerates the exact data fields returned. The word 'historical' plus the time-window framing distinguishes it from siblings check_token_risk and check_token_risk_batch, which sound current-state oriented.
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 clearly implies when to use it: when a historical trend over multiple days is needed, not a current snapshot. It does not explicitly name the sibling alternatives or state when not to use the tool, but the context is unambiguous enough for an agent to make the right choice.
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.
check_token_riskcheck_token_risk_batchget_token_risk_history
Add one secure layer between your agents and this server.